+
-Epicyon is a modern [ActivityPub](https://www.w3.org/TR/activitypub) compliant server implementing both S2S and C2S protocols and suitable for installation on single board computers. It includes features such as moderation tools, post expiry, content warnings, image descriptions, news feed and perimeter defense against adversaries. It contains *no JavaScript* and uses HTML+CSS with a Python backend.
+Epicyon is a [fediverse](https://en.wikipedia.org/wiki/Fediverse) server suitable for self-hosting a small number of accounts on low power systems.
-[Project Goals](README_goals.md) - [Commandline interface](README_commandline.md) - [Customizations](README_customizations.md) - [Software Architecture](README_architecture.md) - [Code of Conduct](code-of-conduct.md)
+Key features:
+
+ * Open standards: HTML, CSS, ActivityPub, RSS, CalDAV.
+ * Supports common web browsers and [shell browsers](https://lynx.invisible-island.net).
+ * Will not drain your mobile or laptop battery.
+ * Customisable themes. It doesn't have to look bland.
+ * Emoji reactions.
+ * Geospatial hashtags.
+ * Does not require much RAM, either on server or client.
+ * Suitable for installation on single board computers.
+ * No timeline algorithms.
+ * No javascript.
+ * No database. Data stored as ordinary files.
+ * No fashionable web frameworks. *"Boring by design"*.
+ * No blockchain garbage.
+ * Written in Python, with few dependencies.
+ * AGPL license, which big tech hates.
+
+Epicyon is for people who are tired of *big anything* and just want to DIY their online social experience without much fuss or expense. Think *water cooler discussions* rather than *shouting into the void*, in which you're mainly just reading and responding to the posts of people that you're following.
+
+[Project Goals](README_goals.md) - [Commandline interface](README_commandline.md) - [Customizations](README_customizations.md) - [Software Architecture](README_architecture.md) - [Code of Conduct](code-of-conduct.md) - [Principles of Unity](principlesofunity.md) - [C2S Desktop Client](README_desktop_client.md) - [Coding Style](README_coding_style.md)
Matrix room: **#epicyon:matrix.libreserver.org**
@@ -29,8 +49,8 @@ On Arch/Parabola:
``` bash
sudo pacman -S tor python-pip python-pysocks python-cryptography \
imagemagick python-requests \
- perl-image-exiftool python-dateutil \
- certbot flake8 bandit
+ perl-image-exiftool python-dateutil \
+ certbot flake8 bandit
sudo pip3 install pyqrcode pypng
```
@@ -55,6 +75,13 @@ In the most common case you'll be using systemd to set up a daemon to run the se
The following instructions install Epicyon to the **/opt** directory. It's not essential that it be installed there, and it could be in any other preferred directory.
+Clone the repo, or if you downloaded the tarball then extract it into the **/opt** directory.
+
+``` bash
+cd /opt
+git clone https://gitlab.com/bashrc2/epicyon
+```
+
Add a dedicated user so that we don't have to run as root.
``` bash
@@ -82,11 +109,32 @@ Type=simple
User=epicyon
Group=epicyon
WorkingDirectory=/opt/epicyon
-ExecStart=/usr/bin/python3 /opt/epicyon/epicyon.py --port 443 --proxy 7156 --domain YOUR_DOMAIN --registration open --logLoginFailures
+ExecStart=/usr/bin/python3 /opt/epicyon/epicyon.py --port 443 --proxy 7156 --domain YOUR_DOMAIN --registration open --log_login_failures
Environment=USER=epicyon
Environment=PYTHONUNBUFFERED=true
Restart=always
StandardError=syslog
+CPUQuota=80%
+ProtectHome=true
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+ProtectKernelLogs=true
+ProtectHostname=true
+ProtectClock=true
+ProtectProc=invisible
+ProcSubset=pid
+PrivateTmp=true
+PrivateUsers=true
+PrivateDevices=true
+PrivateIPC=true
+MemoryDenyWriteExecute=true
+NoNewPrivileges=true
+LockPersonality=true
+RestrictRealtime=true
+RestrictSUIDSGID=true
+RestrictNamespaces=true
+SystemCallArchitectures=native
[Install]
WantedBy=multi-user.target
@@ -134,6 +182,16 @@ server {
listen 443 ssl;
server_name YOUR_DOMAIN;
+ gzip on;
+ gzip_disable "msie6";
+ gzip_vary on;
+ gzip_proxied any;
+ gzip_min_length 1024;
+ gzip_comp_level 6;
+ gzip_buffers 16 8k;
+ gzip_http_version 1.1;
+ gzip_types text/plain text/css application/json application/ld+json application/javascript text/xml application/xml application/rdf+xml application/xml+rss text/javascript;
+
ssl_stapling off;
ssl_stapling_verify off;
ssl on;
@@ -141,19 +199,19 @@ server {
ssl_certificate_key /etc/letsencrypt/live/YOUR_DOMAIN/privkey.pem;
#ssl_dhparam /etc/ssl/certs/YOUR_DOMAIN.dhparam;
- ssl_session_cache builtin:1000 shared:SSL:10m;
- ssl_session_timeout 60m;
- ssl_prefer_server_ciphers on;
ssl_protocols TLSv1.2 TLSv1.3;
- ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS';
+ ssl_ciphers HIGH:!MEDIUM:!LOW:!aNULL:!NULL:!SHA;
+ ssl_prefer_server_ciphers on;
+ ssl_session_cache shared:SSL:10m;
+ ssl_session_tickets off;
+
+ add_header Content-Security-Policy "default-src https:; script-src https: 'unsafe-inline'; style-src https: 'unsafe-inline'";
add_header X-Frame-Options DENY;
add_header X-Content-Type-Options nosniff;
add_header X-XSS-Protection "1; mode=block";
add_header X-Download-Options noopen;
add_header X-Permitted-Cross-Domain-Policies none;
-
- add_header X-Robots-Tag "noindex, nofollow, nosnippet, noarchive";
- add_header Strict-Transport-Security max-age=15768000;
+ add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload" always;
access_log /dev/null;
error_log /dev/null;
@@ -165,6 +223,9 @@ server {
try_files $uri =404;
}
+ keepalive_timeout 70;
+ sendfile on;
+
location / {
proxy_http_version 1.1;
client_max_body_size 31M;
@@ -184,6 +245,7 @@ server {
proxy_request_buffering off;
proxy_buffering off;
proxy_pass http://localhost:7156;
+ tcp_nodelay on;
}
}
```
@@ -197,7 +259,9 @@ ln -s /etc/nginx/sites-available/YOUR_DOMAIN /etc/nginx/sites-enabled/
Generate a LetsEncrypt certificate.
``` bash
+systemctl stop nginx
certbot certonly -n --server https://acme-v02.api.letsencrypt.org/directory --standalone -d YOUR_DOMAIN --renew-by-default --agree-tos --email YOUR_EMAIL
+systemctl start nginx
```
And restart the web server:
@@ -278,3 +342,13 @@ To run the network tests. These simulate instances exchanging messages.
``` bash
python3 epicyon.py --testsnetwork
```
+
+## Software Bill of Materials
+
+To update the software bill of materials:
+
+``` bash
+sudo pip3 install scanoss
+make clean
+make sbom
+```
diff --git a/README_architecture.md b/README_architecture.md
index a7dff92aa..4dcb87bec 100644
--- a/README_architecture.md
+++ b/README_architecture.md
@@ -16,6 +16,10 @@ Although it can be single user, this is not strictly a single user system.
The design of this system is opinionated, and to a large extent informed by years of past experience in the fediverse. There is no claim to neutrality of any sort. Automatic removal of hellthreads and other common griefing tactics is an example of this.
+### Privacy Sensitive Defaults
+
+Follow approval should be required by default. This gives the user a chance to see who wants to follow them and make a decision. Also by default direct messages should not be permitted except with accounts that you are following. This helps to reduce spam and harrassment from random accounts in the wider fediverse. The aim is for the user to have a good experience by default, even if they have not yet built up any sort of block list.
+
### Resisting Centralization
Centralization is characterized by the typical fixation upon "scale" within the software industry. Systems which scale, in the way which is commonly understood, mean that a few individuals can control the social lives of many, and extract value from them in often cynical and manipulative ways.
@@ -24,7 +28,7 @@ In general, methods have been preferred which do not vertically scale. This incl
Being hostile towards the common notion of scaling means that this system will be of no interest to "big tech" and can't easily be used within extractive economic models without needing a substantial rewrite. This avoids the typical cooption strategies in which large companies eventually take over what was originally software developed by grassroots activists to address real community needs.
-This system should however be able to scale rhizomatically with the deployment of many small instances federated together. Instead of scaling up, scale out. In a network of many small instances nobody has overall control and corporate capture is much more unlikely. Small instances also minimize the bureaucratic requirements for governance processes, which at medium to large scale eventually becomes tyrannical.
+This system should however be able to scale rhizomatically with the deployment of many small instances federated together. Instead of scaling up, scale out. In a network of many small instances nobody has overall control and corporate capture is far less feasible. Small instances also minimize the bureaucratic requirements for governance processes, which at medium to large scale eventually becomes tyrannical.
### Roles
@@ -32,11 +36,11 @@ The roles within an instance are comparable to the crew roles onboard a ship, wi
### No Javascript
-This is so that the system can be accessed and used normally with javascript in the web browser turned off. If you want to have good security then this is useful, since lack of javascript greatly reduces the attack surface and constrains adversaries to a limited number of vectors.
+This is so that the system can be accessed and used normally with javascript in the web browser turned off. If you want to have good security then this is useful, since lack of javascript greatly reduces the attack surface and constrains adversaries to a limited number of vectors. Not using javascript also makes this system usable in shell based browsers such as Lynx, or other less common browsers, which helps to avoid being locked in to a browser duopoly.
### Block Crawlers
-Ordinarily web crawlers would not be a problem, but in the context of a social network even having crawlers index public posts can create ethical dilemmas in some circumstances. News instances may allow crawlers, but other types of instances should block them.
+Ordinarily web crawlers would not be a problem, but in the context of a social network even having crawlers index public posts can create ethical dilemmas in some circumstances. News and blogging instances may allow crawlers, but other types of instances should block them.
### No Local or Federated Timelines
@@ -60,6 +64,9 @@ It is usually safe to assume that the federated network beyond your instance is
Where Json linked data signatures are supported there should not be arbitrary schema lookups via the web. Instead, recognized contexts should be added to *context.py*. This is in order to follow the principle of *no processing without full recognition*, in which the recognition step is not endlessly extendable by untrusted parties.
+### Avoid Web Frameworks
+
+In general avoid using web frameworks and instead use local modules which are prefixed with *webapp_*. Web frameworks are built for conventional software engineering by large companies who are designing for scale. They typically have database dependencies and contain a lot of hardcoded Google stuff or other things which will leak metadata or be incompatible with onion routing. Keeping up with web frameworks is a constant firefight. They also create a massive attack surface requiring constant vigilance.
## High Level Architecture
diff --git a/README_coding_style.md b/README_coding_style.md
new file mode 100644
index 000000000..4b4c47742
--- /dev/null
+++ b/README_coding_style.md
@@ -0,0 +1,21 @@
+# Epicyon Coding Style
+
+Try to keep to the typical PEP8 coding style supported by Python static analysis systems.
+
+Variables all lower case and using underscores to separate words (snake case).
+
+Variables sent via webforms (with name="someVariableName") or within config.json are usually CamelCase, in order to clearly distinguish those from ordinary program variables.
+
+Procedural style. Think "C style in Python". Avoid classes and objects as far as possible. This avoids *obfuscation via abstractions*. With procedural style everything is maximally obvious/concrete and can be followed through step by step without needing a lot of implicit background knowledge. Procedural style also makes more rigorous static analysis possible, to catch bugs before they happen at runtime. Mantra: "In the long run, obviousness beats clever abstractions".
+
+Declare all called functions individually at the top of each module. This avoids any possible mistakes with colliding function names, and allows static analysis to explicitly check all dependencies.
+
+Don't use any features of Python which are not supported by the version of Python within the current Debian stable release. Don't assume that all users are running the latest cutting-edge Python release.
+
+Before doing a commit run all the unit tests. There are three layers of testing. The first just checks PEP8 compliance. The second runs a more thorough static analysis and unit tests. The third simulates instances communicating with each other.
+
+```bash
+./static_analysis
+python3 epicyon.py --tests
+python3 epicyon.py --testsnetwork
+```
diff --git a/README_commandline.md b/README_commandline.md
index 9529671b9..4ce329da9 100644
--- a/README_commandline.md
+++ b/README_commandline.md
@@ -222,24 +222,32 @@ python3 epicyon.py --nickname [yournick] --domain [name] \
--undolike [url] --password [c2s password]
```
-## Archiving posts
+## Archiving and Expiring posts
-You can archive old posts with:
+As a general rule, all posts will be retained unless otherwise specified. However, on systems with finite and small disk storage running out of space is a show-stopping catastrophe and so clearing down old posts is highly advisable. You can achieve this using the archive commandline option, and optionally also with a cron job.
+
+You can archive old posts and expire posts as specified within account profile settings with:
``` bash
python3 epicyon.py --archive [directory]
```
-Which will move old posts to the given directory. You can also specify the number of weeks after which images will be archived, and the maximum number of posts within in/outboxes.
+Which will move old posts to the given directory and delete any expired posts. You can also specify the number of weeks after which images will be archived, and the maximum number of posts within in/outboxes.
``` bash
-python3 epicyon.py --archive [directory] --archiveweeks 4 --maxposts 256
+python3 epicyon.py --archive [directory] --archiveweeks 4 --maxposts 32000
```
If you want old posts to be deleted for data minimization purposes then the archive location can be set to */dev/null*.
``` bash
-python3 epicyon.py --archive /dev/null --archiveweeks 4 --maxposts 256
+python3 epicyon.py --archive /dev/null --archiveweeks 4 --maxposts 32000
+```
+
+You can put this command into a cron job to ensure that old posts are cleared down regularly. In */etc/crontab* add an entry such as:
+
+``` bash
+*/60 * * * * root cd /opt/epicyon && /usr/bin/python3 epicyon.py --archive /dev/null --archiveweeks 4 --maxposts 32000
```
## Blocking and unblocking
@@ -372,3 +380,31 @@ To remove a shared item:
``` bash
python3 epicyon.py --undoItemName "spanner" --nickname [yournick] --domain [yourdomain] --password [c2s password]
```
+
+## Calendar
+
+The calendar for each account can be accessed via CalDav (RFC4791). This makes it easy to integrate the social calendar into other applications. For example, to obtain events for a month:
+
+```bash
+python3 epicyon.py --dav --nickname [yournick] --domain [yourdomain] --year [year] --month [month number]
+```
+
+You will be prompted for your login password, or you can use the **--password** option. You can also use the **--day** option to obtain events for a particular day.
+
+The CalDav endpoint for an account is:
+
+```bash
+yourdomain/calendars/yournick
+```
+
+## Web Crawlers
+
+Having search engines index social media posts is not usually considered appropriate, since even if "public" they may contain personally identifiable information. If you are running a news instance then web crawlers will be permitted by the system, but otherwise by default they will be blocked.
+
+If you want to allow specific web crawlers then when running the daemon (typically with systemd) you can use the **crawlersAllowed** option. It can take a list of bot names, separated by commas. For example:
+
+```bash
+--crawlersAllowed "googlebot, apple"
+```
+
+Typically web crawlers have names ending in "bot", but partial names can also be used.
diff --git a/README_customizations.md b/README_customizations.md
index a6f86ad7d..462ee1cdd 100644
--- a/README_customizations.md
+++ b/README_customizations.md
@@ -26,6 +26,20 @@ When a moderator report is created the message at the top of the screen can be c
Extra emoji can be added to the *emoji* directory and you should then update the **emoji/emoji.json** file, which maps the name to the filename (without the .png extension).
+Another way to import emoji is to create a text file where each line is the url of the emoji png file and the emoji name, separated by a comma.
+
+```bash
+https://somesite/emoji1.png, :emojiname1:
+https://somesite/emoji2.png, :emojiname2:
+https://somesite/emoji3.png, :emojiname3:
+```
+
+Then this can be imported with:
+
+```bash
+python3 epicyon.py --import-emoji [textfile]
+```
+
## Themes
-If you want to create a new theme then the functions for that are within *theme.py*. These functions take the CSS templates and modify them. You will need to edit *themesDropdown* within *webinterface.py* and add the appropriate translations for the theme name. Themes are selectable from the profile screen of the administrator.
+If you want to create a new theme then copy the *default* directory within the *theme* directory, rename it to your new theme name, then you can edit the colors and fonts within *theme.json*, and change the icons and banners. Themes are selectable from the graphic design section of the profile screen of the administrator, or of any accounts having the *artist* role.
diff --git a/README_desktop_client.md b/README_desktop_client.md
index a1ac25fe6..4b84d4d4c 100644
--- a/README_desktop_client.md
+++ b/README_desktop_client.md
@@ -1,4 +1,6 @@
-# Desktop client
+# C2S Desktop client
+
+
## Installing and running
@@ -26,6 +28,12 @@ Or if you have picospeaker installed:
~/epicyon-client-pico
```
+Or if you have mimic3 installed:
+
+``` bash
+~/epicyon-client-mimic3
+```
+
## Commands
The desktop client has a few commands, which may be more convenient than the web interface for some purposes:
@@ -85,7 +93,13 @@ Or a quicker version, if you have installed the desktop client as described abov
Or if you have [picospeaker](https://gitlab.com/ky1e/picospeaker) installed:
``` bash
-python3 epicyon.py --notifyShowNewPosts --screenreader picospeaker --desktop yournickname@yourdomain
+~/epicyon-stream-pico
+```
+
+Or if you have mimic3 installed:
+
+``` bash
+~/epicyon-stream-mimic3
```
You can also use the **--password** option to provide the password. This will then stay running and incoming posts will be announced as they arrive.
diff --git a/README_goals.md b/README_goals.md
index 531bc467d..e37b070ca 100644
--- a/README_goals.md
+++ b/README_goals.md
@@ -45,6 +45,7 @@ The following are considered anti-features of other social network systems, sinc
* Algorithmic timelines (i.e. non-chronological)
* Direct payment mechanisms, although integration with other services may be possible
* Any variety of blockchain
+ * Non Fungible Token (NFT) features
* Anything based upon "proof of stake". The "people who have more, get more" principle should be rejected.
* Like counts above some small maximum number. The aim is to avoid people getting addicted to making numbers go up, and especially to avoid the dark market in fake likes.
* Sponsored posts
diff --git a/README_roadmap.md b/README_roadmap.md
index b1a6eb428..5f80b83e3 100644
--- a/README_roadmap.md
+++ b/README_roadmap.md
@@ -7,7 +7,6 @@
## Groups
* Groups can be defined as having particular roles/skills
- * Parse posts from Lemmy groups
* Think of a way to display groups. Maybe assign a hashtag and display them like hashtag timelines
## Questions
@@ -20,7 +19,5 @@
## Code
* More unit test coverage
- * Unit test for federated shared items
* Break up large functions into smaller ones
- * Architecture diagrams
* Code documentation?
diff --git a/acceptreject.py b/acceptreject.py
index bd54600c3..dc529779f 100644
--- a/acceptreject.py
+++ b/acceptreject.py
@@ -1,220 +1,231 @@
__filename__ = "acceptreject.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
__module_group__ = "ActivityPub"
import os
-from utils import hasUsersPath
-from utils import getFullDomain
-from utils import urlPermitted
-from utils import getDomainFromActor
-from utils import getNicknameFromActor
-from utils import domainPermitted
-from utils import followPerson
-from utils import hasObjectDict
-from utils import acctDir
-from utils import hasGroupType
-from utils import localActorUrl
+from utils import text_in_file
+from utils import has_object_string_object
+from utils import has_users_path
+from utils import get_full_domain
+from utils import url_permitted
+from utils import get_domain_from_actor
+from utils import get_nickname_from_actor
+from utils import domain_permitted
+from utils import follow_person
+from utils import acct_dir
+from utils import has_group_type
+from utils import local_actor_url
+from utils import has_actor
+from utils import has_object_string_type
-def _createAcceptReject(baseDir: str, federationList: [],
- nickname: str, domain: str, port: int,
- toUrl: str, ccUrl: str, httpPrefix: str,
- objectJson: {}, acceptType: str) -> {}:
+def _create_accept_reject(base_dir: str, federation_list: [],
+ nickname: str, domain: str, port: int,
+ to_url: str, cc_url: str, http_prefix: str,
+ object_json: {}, accept_type: str) -> {}:
"""Accepts or rejects something (eg. a follow request or offer)
- Typically toUrl will be https://www.w3.org/ns/activitystreams#Public
- and ccUrl might be a specific person favorited or repeated and
+ Typically to_url will be https://www.w3.org/ns/activitystreams#Public
+ and cc_url might be a specific person favorited or repeated and
the followers url objectUrl is typically the url of the message,
corresponding to url or atomUri in createPostBase
"""
- if not objectJson.get('actor'):
+ if not object_json.get('actor'):
return None
- if not urlPermitted(objectJson['actor'], federationList):
+ if not url_permitted(object_json['actor'], federation_list):
return None
- domain = getFullDomain(domain, port)
+ domain = get_full_domain(domain, port)
- newAccept = {
+ new_accept = {
"@context": "https://www.w3.org/ns/activitystreams",
- 'type': acceptType,
- 'actor': localActorUrl(httpPrefix, nickname, domain),
- 'to': [toUrl],
+ 'type': accept_type,
+ 'actor': local_actor_url(http_prefix, nickname, domain),
+ 'to': [to_url],
'cc': [],
- 'object': objectJson
+ 'object': object_json
}
- if ccUrl:
- if len(ccUrl) > 0:
- newAccept['cc'] = [ccUrl]
- return newAccept
+ if cc_url:
+ if len(cc_url) > 0:
+ new_accept['cc'] = [cc_url]
+ return new_accept
-def createAccept(baseDir: str, federationList: [],
- nickname: str, domain: str, port: int,
- toUrl: str, ccUrl: str, httpPrefix: str,
- objectJson: {}) -> {}:
- return _createAcceptReject(baseDir, federationList,
- nickname, domain, port,
- toUrl, ccUrl, httpPrefix,
- objectJson, 'Accept')
+def create_accept(base_dir: str, federation_list: [],
+ nickname: str, domain: str, port: int,
+ to_url: str, cc_url: str, http_prefix: str,
+ object_json: {}) -> {}:
+ return _create_accept_reject(base_dir, federation_list,
+ nickname, domain, port,
+ to_url, cc_url, http_prefix,
+ object_json, 'Accept')
-def createReject(baseDir: str, federationList: [],
- nickname: str, domain: str, port: int,
- toUrl: str, ccUrl: str, httpPrefix: str,
- objectJson: {}) -> {}:
- return _createAcceptReject(baseDir, federationList,
- nickname, domain, port,
- toUrl, ccUrl,
- httpPrefix, objectJson, 'Reject')
+def create_reject(base_dir: str, federation_list: [],
+ nickname: str, domain: str, port: int,
+ to_url: str, cc_url: str, http_prefix: str,
+ object_json: {}) -> {}:
+ return _create_accept_reject(base_dir, federation_list,
+ nickname, domain, port,
+ to_url, cc_url,
+ http_prefix, object_json, 'Reject')
-def _acceptFollow(baseDir: str, domain: str, messageJson: {},
- federationList: [], debug: bool) -> None:
+def _accept_follow(base_dir: str, message_json: {},
+ federation_list: [], debug: bool,
+ curr_domain: str,
+ onion_domain: str, i2p_domain: str) -> None:
"""Receiving a follow Accept activity
"""
- if not hasObjectDict(messageJson):
+ if not has_object_string_type(message_json, debug):
return
- if not messageJson['object'].get('type'):
- return
- if not messageJson['object']['type'] == 'Follow':
- if not messageJson['object']['type'] == 'Join':
+ if not message_json['object']['type'] == 'Follow':
+ if not message_json['object']['type'] == 'Join':
return
if debug:
print('DEBUG: receiving Follow activity')
- if not messageJson['object'].get('actor'):
+ if not message_json['object'].get('actor'):
print('DEBUG: no actor in Follow activity')
return
# no, this isn't a mistake
- if not messageJson['object'].get('object'):
- print('DEBUG: no object within Follow activity')
+ if not has_object_string_object(message_json, debug):
return
- if not messageJson.get('to'):
+ if not message_json.get('to'):
if debug:
print('DEBUG: No "to" parameter in follow Accept')
return
if debug:
- print('DEBUG: follow Accept received')
- thisActor = messageJson['object']['actor']
- nickname = getNicknameFromActor(thisActor)
+ print('DEBUG: follow Accept received ' + str(message_json))
+ this_actor = message_json['object']['actor']
+ nickname = get_nickname_from_actor(this_actor)
if not nickname:
- print('WARN: no nickname found in ' + thisActor)
+ print('WARN: no nickname found in ' + this_actor)
return
- acceptedDomain, acceptedPort = getDomainFromActor(thisActor)
- if not acceptedDomain:
+ accepted_domain, accepted_port = get_domain_from_actor(this_actor)
+ if not accepted_domain:
if debug:
- print('DEBUG: domain not found in ' + thisActor)
+ print('DEBUG: domain not found in ' + this_actor)
return
if not nickname:
if debug:
- print('DEBUG: nickname not found in ' + thisActor)
+ print('DEBUG: nickname not found in ' + this_actor)
return
- if acceptedPort:
- if '/' + acceptedDomain + ':' + str(acceptedPort) + \
- '/users/' + nickname not in thisActor:
+ if accepted_port:
+ if '/' + accepted_domain + ':' + str(accepted_port) + \
+ '/users/' + nickname not in this_actor:
if debug:
- print('Port: ' + str(acceptedPort))
- print('Expected: /' + acceptedDomain + ':' +
- str(acceptedPort) + '/users/' + nickname)
- print('Actual: ' + thisActor)
- print('DEBUG: unrecognized actor ' + thisActor)
+ print('Port: ' + str(accepted_port))
+ print('Expected: /' + accepted_domain + ':' +
+ str(accepted_port) + '/users/' + nickname)
+ print('Actual: ' + this_actor)
+ print('DEBUG: unrecognized actor ' + this_actor)
return
else:
- if not '/' + acceptedDomain + '/users/' + nickname in thisActor:
+ if not '/' + accepted_domain + '/users/' + nickname in this_actor:
if debug:
- print('Expected: /' + acceptedDomain + '/users/' + nickname)
- print('Actual: ' + thisActor)
- print('DEBUG: unrecognized actor ' + thisActor)
+ print('Expected: /' + accepted_domain + '/users/' + nickname)
+ print('Actual: ' + this_actor)
+ print('DEBUG: unrecognized actor ' + this_actor)
return
- followedActor = messageJson['object']['object']
- followedDomain, port = getDomainFromActor(followedActor)
- if not followedDomain:
+ followed_actor = message_json['object']['object']
+ followed_domain, port = get_domain_from_actor(followed_actor)
+ if not followed_domain:
print('DEBUG: no domain found within Follow activity object ' +
- followedActor)
+ followed_actor)
return
- followedDomainFull = followedDomain
+ followed_domain_full = followed_domain
if port:
- followedDomainFull = followedDomain + ':' + str(port)
- followedNickname = getNicknameFromActor(followedActor)
- if not followedNickname:
+ followed_domain_full = followed_domain + ':' + str(port)
+ followed_nickname = get_nickname_from_actor(followed_actor)
+ if not followed_nickname:
print('DEBUG: no nickname found within Follow activity object ' +
- followedActor)
+ followed_actor)
return
- acceptedDomainFull = acceptedDomain
- if acceptedPort:
- acceptedDomainFull = acceptedDomain + ':' + str(acceptedPort)
+ # convert from onion/i2p to clearnet accepted domain
+ if onion_domain:
+ if accepted_domain.endswith('.onion') and \
+ not curr_domain.endswith('.onion'):
+ accepted_domain = curr_domain
+ if i2p_domain:
+ if accepted_domain.endswith('.i2p') and \
+ not curr_domain.endswith('.i2p'):
+ accepted_domain = curr_domain
+
+ accepted_domain_full = accepted_domain
+ if accepted_port:
+ accepted_domain_full = accepted_domain + ':' + str(accepted_port)
# has this person already been unfollowed?
- unfollowedFilename = \
- acctDir(baseDir, nickname, acceptedDomainFull) + '/unfollowed.txt'
- if os.path.isfile(unfollowedFilename):
- if followedNickname + '@' + followedDomainFull in \
- open(unfollowedFilename).read():
+ unfollowed_filename = \
+ acct_dir(base_dir, nickname, accepted_domain_full) + '/unfollowed.txt'
+ if os.path.isfile(unfollowed_filename):
+ if text_in_file(followed_nickname + '@' + followed_domain_full,
+ unfollowed_filename):
if debug:
print('DEBUG: follow accept arrived for ' +
- nickname + '@' + acceptedDomainFull +
- ' from ' + followedNickname + '@' + followedDomainFull +
+ nickname + '@' + accepted_domain_full +
+ ' from ' +
+ followed_nickname + '@' + followed_domain_full +
' but they have been unfollowed')
return
# does the url path indicate that this is a group actor
- groupAccount = hasGroupType(baseDir, followedActor, None, debug)
+ group_account = has_group_type(base_dir, followed_actor, None, debug)
if debug:
- print('Accepted follow is a group: ' + str(groupAccount) +
- ' ' + followedActor + ' ' + baseDir)
+ print('Accepted follow is a group: ' + str(group_account) +
+ ' ' + followed_actor + ' ' + base_dir)
- if followPerson(baseDir,
- nickname, acceptedDomainFull,
- followedNickname, followedDomainFull,
- federationList, debug, groupAccount):
+ if follow_person(base_dir,
+ nickname, accepted_domain_full,
+ followed_nickname, followed_domain_full,
+ federation_list, debug, group_account):
if debug:
- print('DEBUG: ' + nickname + '@' + acceptedDomainFull +
- ' followed ' + followedNickname + '@' + followedDomainFull)
+ print('DEBUG: ' + nickname + '@' + accepted_domain_full +
+ ' followed ' +
+ followed_nickname + '@' + followed_domain_full)
else:
if debug:
print('DEBUG: Unable to create follow - ' +
- nickname + '@' + acceptedDomain + ' -> ' +
- followedNickname + '@' + followedDomain)
+ nickname + '@' + accepted_domain + ' -> ' +
+ followed_nickname + '@' + followed_domain)
-def receiveAcceptReject(session, baseDir: str,
- httpPrefix: str, domain: str, port: int,
- sendThreads: [], postLog: [], cachedWebfingers: {},
- personCache: {}, messageJson: {}, federationList: [],
- debug: bool) -> bool:
+def receive_accept_reject(base_dir: str, domain: str, message_json: {},
+ federation_list: [], debug: bool, curr_domain: str,
+ onion_domain: str, i2p_domain: str) -> bool:
"""Receives an Accept or Reject within the POST section of HTTPServer
"""
- if messageJson['type'] != 'Accept' and messageJson['type'] != 'Reject':
+ if message_json['type'] != 'Accept' and message_json['type'] != 'Reject':
return False
- if not messageJson.get('actor'):
- if debug:
- print('DEBUG: ' + messageJson['type'] + ' has no actor')
+ if not has_actor(message_json, debug):
return False
- if not hasUsersPath(messageJson['actor']):
+ if not has_users_path(message_json['actor']):
if debug:
print('DEBUG: "users" or "profile" missing from actor in ' +
- messageJson['type'] + '. Assuming single user instance.')
- domain, tempPort = getDomainFromActor(messageJson['actor'])
- if not domainPermitted(domain, federationList):
+ message_json['type'] + '. Assuming single user instance.')
+ domain, _ = get_domain_from_actor(message_json['actor'])
+ if not domain_permitted(domain, federation_list):
if debug:
- print('DEBUG: ' + messageJson['type'] +
+ print('DEBUG: ' + message_json['type'] +
' from domain not permitted - ' + domain)
return False
- nickname = getNicknameFromActor(messageJson['actor'])
+ nickname = get_nickname_from_actor(message_json['actor'])
if not nickname:
# single user instance
nickname = 'dev'
if debug:
- print('DEBUG: ' + messageJson['type'] +
+ print('DEBUG: ' + message_json['type'] +
' does not contain a nickname. ' +
'Assuming single user instance.')
# receive follow accept
- _acceptFollow(baseDir, domain, messageJson, federationList, debug)
+ _accept_follow(base_dir, message_json, federation_list, debug,
+ curr_domain, onion_domain, i2p_domain)
if debug:
- print('DEBUG: Uh, ' + messageJson['type'] + ', I guess')
+ print('DEBUG: Uh, ' + message_json['type'] + ', I guess')
return True
diff --git a/announce.py b/announce.py
index 603fd8af1..1bc3c538f 100644
--- a/announce.py
+++ b/announce.py
@@ -1,433 +1,445 @@
__filename__ = "announce.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
__module_group__ = "ActivityPub"
-from utils import hasGroupType
-from utils import removeDomainPort
-from utils import hasObjectDict
-from utils import removeIdEnding
-from utils import hasUsersPath
-from utils import getFullDomain
-from utils import getStatusNumber
-from utils import createOutboxDir
-from utils import urlPermitted
-from utils import getNicknameFromActor
-from utils import getDomainFromActor
-from utils import locatePost
-from utils import saveJson
-from utils import undoAnnounceCollectionEntry
-from utils import updateAnnounceCollection
-from utils import localActorUrl
-from utils import replaceUsersWithAt
-from posts import sendSignedJson
-from posts import getPersonBox
-from session import postJson
-from webfinger import webfingerHandle
-from auth import createBasicAuthHeader
+from utils import has_object_string_object
+from utils import has_group_type
+from utils import has_object_dict
+from utils import remove_domain_port
+from utils import remove_id_ending
+from utils import has_users_path
+from utils import get_full_domain
+from utils import get_status_number
+from utils import create_outbox_dir
+from utils import url_permitted
+from utils import get_nickname_from_actor
+from utils import get_domain_from_actor
+from utils import locate_post
+from utils import save_json
+from utils import undo_announce_collection_entry
+from utils import update_announce_collection
+from utils import local_actor_url
+from utils import replace_users_with_at
+from utils import has_actor
+from utils import has_object_string_type
+from posts import send_signed_json
+from posts import get_person_box
+from session import post_json
+from webfinger import webfinger_handle
+from auth import create_basic_auth_header
-def isSelfAnnounce(postJsonObject: {}) -> bool:
+def no_of_announces(post_json_object: {}) -> int:
+ """Returns the number of announces on a given post
+ """
+ obj = post_json_object
+ if has_object_dict(post_json_object):
+ obj = post_json_object['object']
+ if not obj.get('shares'):
+ return 0
+ if not isinstance(obj['shares'], dict):
+ return 0
+ if not obj['shares'].get('items'):
+ obj['shares']['items'] = []
+ obj['shares']['totalItems'] = 0
+ return len(obj['shares']['items'])
+
+
+def is_self_announce(post_json_object: {}) -> bool:
"""Is the given post a self announce?
"""
- if not postJsonObject.get('actor'):
+ if not post_json_object.get('actor'):
return False
- if not postJsonObject.get('type'):
+ if not post_json_object.get('type'):
return False
- if postJsonObject['type'] != 'Announce':
+ if post_json_object['type'] != 'Announce':
return False
- if not postJsonObject.get('object'):
+ if not post_json_object.get('object'):
return False
- if not isinstance(postJsonObject['actor'], str):
+ if not isinstance(post_json_object['actor'], str):
return False
- if not isinstance(postJsonObject['object'], str):
+ if not isinstance(post_json_object['object'], str):
return False
- return postJsonObject['actor'] in postJsonObject['object']
+ return post_json_object['actor'] in post_json_object['object']
-def outboxAnnounce(recentPostsCache: {},
- baseDir: str, messageJson: {}, debug: bool) -> bool:
+def outbox_announce(recent_posts_cache: {},
+ base_dir: str, message_json: {}, debug: bool) -> bool:
""" Adds or removes announce entries from the shares collection
within a given post
"""
- if not messageJson.get('actor'):
+ if not has_actor(message_json, debug):
return False
- if not isinstance(messageJson['actor'], str):
+ if not isinstance(message_json['actor'], str):
return False
- if not messageJson.get('type'):
+ if not message_json.get('type'):
return False
- if not messageJson.get('object'):
+ if not message_json.get('object'):
return False
- if messageJson['type'] == 'Announce':
- if not isinstance(messageJson['object'], str):
+ if message_json['type'] == 'Announce':
+ if not isinstance(message_json['object'], str):
return False
- if isSelfAnnounce(messageJson):
+ if is_self_announce(message_json):
return False
- nickname = getNicknameFromActor(messageJson['actor'])
+ nickname = get_nickname_from_actor(message_json['actor'])
if not nickname:
- print('WARN: no nickname found in ' + messageJson['actor'])
+ print('WARN: no nickname found in ' + message_json['actor'])
return False
- domain, port = getDomainFromActor(messageJson['actor'])
- postFilename = locatePost(baseDir, nickname, domain,
- messageJson['object'])
- if postFilename:
- updateAnnounceCollection(recentPostsCache, baseDir, postFilename,
- messageJson['actor'],
- nickname, domain, debug)
+ domain, _ = get_domain_from_actor(message_json['actor'])
+ post_filename = locate_post(base_dir, nickname, domain,
+ message_json['object'])
+ if post_filename:
+ update_announce_collection(recent_posts_cache,
+ base_dir, post_filename,
+ message_json['actor'],
+ nickname, domain, debug)
return True
- elif messageJson['type'] == 'Undo':
- if not hasObjectDict(messageJson):
+ elif message_json['type'] == 'Undo':
+ if not has_object_string_type(message_json, debug):
return False
- if not messageJson['object'].get('type'):
- return False
- if messageJson['object']['type'] == 'Announce':
- if not isinstance(messageJson['object']['object'], str):
+ if message_json['object']['type'] == 'Announce':
+ if not isinstance(message_json['object']['object'], str):
return False
- nickname = getNicknameFromActor(messageJson['actor'])
+ nickname = get_nickname_from_actor(message_json['actor'])
if not nickname:
- print('WARN: no nickname found in ' + messageJson['actor'])
+ print('WARN: no nickname found in ' + message_json['actor'])
return False
- domain, port = getDomainFromActor(messageJson['actor'])
- postFilename = locatePost(baseDir, nickname, domain,
- messageJson['object']['object'])
- if postFilename:
- undoAnnounceCollectionEntry(recentPostsCache,
- baseDir, postFilename,
- messageJson['actor'],
- domain, debug)
+ domain, _ = get_domain_from_actor(message_json['actor'])
+ post_filename = locate_post(base_dir, nickname, domain,
+ message_json['object']['object'])
+ if post_filename:
+ undo_announce_collection_entry(recent_posts_cache,
+ base_dir, post_filename,
+ message_json['actor'],
+ domain, debug)
return True
return False
-def announcedByPerson(isAnnounced: bool, postActor: str,
- nickname: str, domainFull: str) -> bool:
+def announced_by_person(is_announced: bool, post_actor: str,
+ nickname: str, domain_full: str) -> bool:
"""Returns True if the given post is announced by the given person
"""
- if not postActor:
+ if not post_actor:
return False
- if isAnnounced and \
- postActor.endswith(domainFull + '/users/' + nickname):
+ if is_announced and \
+ post_actor.endswith(domain_full + '/users/' + nickname):
return True
return False
-def createAnnounce(session, baseDir: str, federationList: [],
- nickname: str, domain: str, port: int,
- toUrl: str, ccUrl: str, httpPrefix: str,
- objectUrl: str, saveToFile: bool,
- clientToServer: bool,
- sendThreads: [], postLog: [],
- personCache: {}, cachedWebfingers: {},
- debug: bool, projectVersion: str,
- signingPrivateKeyPem: str) -> {}:
+def create_announce(session, base_dir: str, federation_list: [],
+ nickname: str, domain: str, port: int,
+ to_url: str, cc_url: str, http_prefix: str,
+ object_url: str, save_to_file: bool,
+ client_to_server: bool,
+ send_threads: [], post_log: [],
+ person_cache: {}, cached_webfingers: {},
+ debug: bool, project_version: str,
+ signing_priv_key_pem: str,
+ curr_domain: str,
+ onion_domain: str, i2p_domain: str) -> {}:
"""Creates an announce message
- Typically toUrl will be https://www.w3.org/ns/activitystreams#Public
- and ccUrl might be a specific person favorited or repeated and the
- followers url objectUrl is typically the url of the message,
+ Typically to_url will be https://www.w3.org/ns/activitystreams#Public
+ and cc_url might be a specific person favorited or repeated and the
+ followers url object_url is typically the url of the message,
corresponding to url or atomUri in createPostBase
"""
- if not urlPermitted(objectUrl, federationList):
+ if not url_permitted(object_url, federation_list):
return None
- domain = removeDomainPort(domain)
- fullDomain = getFullDomain(domain, port)
+ domain = remove_domain_port(domain)
+ full_domain = get_full_domain(domain, port)
- statusNumber, published = getStatusNumber()
- newAnnounceId = httpPrefix + '://' + fullDomain + \
- '/users/' + nickname + '/statuses/' + statusNumber
- atomUriStr = localActorUrl(httpPrefix, nickname, fullDomain) + \
- '/statuses/' + statusNumber
- newAnnounce = {
+ status_number, published = get_status_number()
+ new_announce_id = http_prefix + '://' + full_domain + \
+ '/users/' + nickname + '/statuses/' + status_number
+ atom_uri_str = local_actor_url(http_prefix, nickname, full_domain) + \
+ '/statuses/' + status_number
+ new_announce = {
"@context": "https://www.w3.org/ns/activitystreams",
- 'actor': localActorUrl(httpPrefix, nickname, fullDomain),
- 'atomUri': atomUriStr,
+ 'actor': local_actor_url(http_prefix, nickname, full_domain),
+ 'atomUri': atom_uri_str,
'cc': [],
- 'id': newAnnounceId + '/activity',
- 'object': objectUrl,
+ 'id': new_announce_id + '/activity',
+ 'object': object_url,
'published': published,
- 'to': [toUrl],
+ 'to': [to_url],
'type': 'Announce'
}
- if ccUrl:
- if len(ccUrl) > 0:
- newAnnounce['cc'] = [ccUrl]
- if saveToFile:
- outboxDir = createOutboxDir(nickname, domain, baseDir)
- filename = outboxDir + '/' + newAnnounceId.replace('/', '#') + '.json'
- saveJson(newAnnounce, filename)
+ if cc_url:
+ if len(cc_url) > 0:
+ new_announce['cc'] = [cc_url]
+ if save_to_file:
+ outbox_dir = create_outbox_dir(nickname, domain, base_dir)
+ filename = \
+ outbox_dir + '/' + new_announce_id.replace('/', '#') + '.json'
+ save_json(new_announce, filename)
- announceNickname = None
- announceDomain = None
- announcePort = None
- groupAccount = False
- if hasUsersPath(objectUrl):
- announceNickname = getNicknameFromActor(objectUrl)
- announceDomain, announcePort = getDomainFromActor(objectUrl)
- if '/' + str(announceNickname) + '/' in objectUrl:
- announceActor = \
- objectUrl.split('/' + announceNickname + '/')[0] + \
- '/' + announceNickname
- if hasGroupType(baseDir, announceActor, personCache):
- groupAccount = True
+ announce_nickname = None
+ announce_domain = None
+ announce_port = None
+ group_account = False
+ if has_users_path(object_url):
+ announce_nickname = get_nickname_from_actor(object_url)
+ if announce_nickname:
+ announce_domain, announce_port = get_domain_from_actor(object_url)
+ if '/' + str(announce_nickname) + '/' in object_url:
+ announce_actor = \
+ object_url.split('/' + announce_nickname + '/')[0] + \
+ '/' + announce_nickname
+ if has_group_type(base_dir, announce_actor, person_cache):
+ group_account = True
- if announceNickname and announceDomain:
- sendSignedJson(newAnnounce, session, baseDir,
- nickname, domain, port,
- announceNickname, announceDomain, announcePort, None,
- httpPrefix, True, clientToServer, federationList,
- sendThreads, postLog, cachedWebfingers, personCache,
- debug, projectVersion, None, groupAccount,
- signingPrivateKeyPem, 639633)
+ if announce_nickname and announce_domain:
+ send_signed_json(new_announce, session, base_dir,
+ nickname, domain, port,
+ announce_nickname, announce_domain,
+ announce_port,
+ http_prefix, client_to_server, federation_list,
+ send_threads, post_log, cached_webfingers,
+ person_cache,
+ debug, project_version, None, group_account,
+ signing_priv_key_pem, 639633,
+ curr_domain, onion_domain, i2p_domain)
- return newAnnounce
+ return new_announce
-def announcePublic(session, baseDir: str, federationList: [],
- nickname: str, domain: str, port: int, httpPrefix: str,
- objectUrl: str, clientToServer: bool,
- sendThreads: [], postLog: [],
- personCache: {}, cachedWebfingers: {},
- debug: bool, projectVersion: str,
- signingPrivateKeyPem: str) -> {}:
+def announce_public(session, base_dir: str, federation_list: [],
+ nickname: str, domain: str, port: int, http_prefix: str,
+ object_url: str, client_to_server: bool,
+ send_threads: [], post_log: [],
+ person_cache: {}, cached_webfingers: {},
+ debug: bool, project_version: str,
+ signing_priv_key_pem: str,
+ curr_domain: str,
+ onion_domain: str, i2p_domain: str) -> {}:
"""Makes a public announcement
"""
- fromDomain = getFullDomain(domain, port)
+ from_domain = get_full_domain(domain, port)
- toUrl = 'https://www.w3.org/ns/activitystreams#Public'
- ccUrl = localActorUrl(httpPrefix, nickname, fromDomain) + '/followers'
- return createAnnounce(session, baseDir, federationList,
- nickname, domain, port,
- toUrl, ccUrl, httpPrefix,
- objectUrl, True, clientToServer,
- sendThreads, postLog,
- personCache, cachedWebfingers,
- debug, projectVersion,
- signingPrivateKeyPem)
+ to_url = 'https://www.w3.org/ns/activitystreams#Public'
+ cc_url = local_actor_url(http_prefix, nickname, from_domain) + '/followers'
+ return create_announce(session, base_dir, federation_list,
+ nickname, domain, port,
+ to_url, cc_url, http_prefix,
+ object_url, True, client_to_server,
+ send_threads, post_log,
+ person_cache, cached_webfingers,
+ debug, project_version,
+ signing_priv_key_pem, curr_domain,
+ onion_domain, i2p_domain)
-def sendAnnounceViaServer(baseDir: str, session,
- fromNickname: str, password: str,
- fromDomain: str, fromPort: int,
- httpPrefix: str, repeatObjectUrl: str,
- cachedWebfingers: {}, personCache: {},
- debug: bool, projectVersion: str,
- signingPrivateKeyPem: str) -> {}:
+def send_announce_via_server(base_dir: str, session,
+ from_nickname: str, password: str,
+ from_domain: str, from_port: int,
+ http_prefix: str, repeat_object_url: str,
+ cached_webfingers: {}, person_cache: {},
+ debug: bool, project_version: str,
+ signing_priv_key_pem: str) -> {}:
"""Creates an announce message via c2s
"""
if not session:
- print('WARN: No session for sendAnnounceViaServer')
+ print('WARN: No session for send_announce_via_server')
return 6
- fromDomainFull = getFullDomain(fromDomain, fromPort)
+ from_domain_full = get_full_domain(from_domain, from_port)
- toUrl = 'https://www.w3.org/ns/activitystreams#Public'
- actorStr = localActorUrl(httpPrefix, fromNickname, fromDomainFull)
- ccUrl = actorStr + '/followers'
+ to_url = 'https://www.w3.org/ns/activitystreams#Public'
+ actor_str = local_actor_url(http_prefix, from_nickname, from_domain_full)
+ cc_url = actor_str + '/followers'
- statusNumber, published = getStatusNumber()
- newAnnounceId = actorStr + '/statuses/' + statusNumber
- newAnnounceJson = {
+ status_number, published = get_status_number()
+ new_announce_id = actor_str + '/statuses/' + status_number
+ new_announce_json = {
"@context": "https://www.w3.org/ns/activitystreams",
- 'actor': actorStr,
- 'atomUri': newAnnounceId,
- 'cc': [ccUrl],
- 'id': newAnnounceId + '/activity',
- 'object': repeatObjectUrl,
+ 'actor': actor_str,
+ 'atomUri': new_announce_id,
+ 'cc': [cc_url],
+ 'id': new_announce_id + '/activity',
+ 'object': repeat_object_url,
'published': published,
- 'to': [toUrl],
+ 'to': [to_url],
'type': 'Announce'
}
- handle = httpPrefix + '://' + fromDomainFull + '/@' + fromNickname
+ handle = http_prefix + '://' + from_domain_full + '/@' + from_nickname
# lookup the inbox for the To handle
- wfRequest = webfingerHandle(session, handle, httpPrefix,
- cachedWebfingers,
- fromDomain, projectVersion, debug, False,
- signingPrivateKeyPem)
- if not wfRequest:
+ wf_request = webfinger_handle(session, handle, http_prefix,
+ cached_webfingers,
+ from_domain, project_version, debug, False,
+ signing_priv_key_pem)
+ if not wf_request:
if debug:
print('DEBUG: announce webfinger failed for ' + handle)
return 1
- if not isinstance(wfRequest, dict):
+ if not isinstance(wf_request, dict):
print('WARN: announce webfinger for ' + handle +
- ' did not return a dict. ' + str(wfRequest))
+ ' did not return a dict. ' + str(wf_request))
return 1
- postToBox = 'outbox'
+ post_to_box = 'outbox'
# get the actor inbox for the To handle
- originDomain = fromDomain
- (inboxUrl, pubKeyId, pubKey, fromPersonId,
- sharedInbox, avatarUrl,
- displayName, _) = getPersonBox(signingPrivateKeyPem,
- originDomain,
- baseDir, session, wfRequest,
- personCache,
- projectVersion, httpPrefix,
- fromNickname, fromDomain,
- postToBox, 73528)
+ origin_domain = from_domain
+ (inbox_url, _, _, from_person_id,
+ _, _, _, _) = get_person_box(signing_priv_key_pem,
+ origin_domain,
+ base_dir, session, wf_request,
+ person_cache,
+ project_version, http_prefix,
+ from_nickname, from_domain,
+ post_to_box, 73528)
- if not inboxUrl:
+ if not inbox_url:
if debug:
- print('DEBUG: announce no ' + postToBox +
+ print('DEBUG: announce no ' + post_to_box +
' was found for ' + handle)
return 3
- if not fromPersonId:
+ if not from_person_id:
if debug:
print('DEBUG: announce no actor was found for ' + handle)
return 4
- authHeader = createBasicAuthHeader(fromNickname, password)
+ auth_header = create_basic_auth_header(from_nickname, password)
headers = {
- 'host': fromDomain,
+ 'host': from_domain,
'Content-type': 'application/json',
- 'Authorization': authHeader
+ 'Authorization': auth_header
}
- postResult = postJson(httpPrefix, fromDomainFull,
- session, newAnnounceJson, [], inboxUrl,
- headers, 3, True)
- if not postResult:
+ post_result = post_json(http_prefix, from_domain_full,
+ session, new_announce_json, [], inbox_url,
+ headers, 3, True)
+ if not post_result:
print('WARN: announce not posted')
if debug:
print('DEBUG: c2s POST announce success')
- return newAnnounceJson
+ return new_announce_json
-def sendUndoAnnounceViaServer(baseDir: str, session,
- undoPostJsonObject: {},
- nickname: str, password: str,
- domain: str, port: int,
- httpPrefix: str, repeatObjectUrl: str,
- cachedWebfingers: {}, personCache: {},
- debug: bool, projectVersion: str,
- signingPrivateKeyPem: str) -> {}:
+def send_undo_announce_via_server(base_dir: str, session,
+ undo_post_json_object: {},
+ nickname: str, password: str,
+ domain: str, port: int, http_prefix: str,
+ cached_webfingers: {}, person_cache: {},
+ debug: bool, project_version: str,
+ signing_priv_key_pem: str) -> {}:
"""Undo an announce message via c2s
"""
if not session:
- print('WARN: No session for sendUndoAnnounceViaServer')
+ print('WARN: No session for send_undo_announce_via_server')
return 6
- domainFull = getFullDomain(domain, port)
+ domain_full = get_full_domain(domain, port)
- actor = localActorUrl(httpPrefix, nickname, domainFull)
- handle = replaceUsersWithAt(actor)
+ actor = local_actor_url(http_prefix, nickname, domain_full)
+ handle = replace_users_with_at(actor)
- statusNumber, published = getStatusNumber()
- unAnnounceJson = {
+ status_number, _ = get_status_number()
+ unannounce_json = {
'@context': 'https://www.w3.org/ns/activitystreams',
- 'id': actor + '/statuses/' + str(statusNumber) + '/undo',
+ 'id': actor + '/statuses/' + str(status_number) + '/undo',
'type': 'Undo',
'actor': actor,
- 'object': undoPostJsonObject['object']
+ 'object': undo_post_json_object['object']
}
# lookup the inbox for the To handle
- wfRequest = webfingerHandle(session, handle, httpPrefix,
- cachedWebfingers,
- domain, projectVersion, debug, False,
- signingPrivateKeyPem)
- if not wfRequest:
+ wf_request = webfinger_handle(session, handle, http_prefix,
+ cached_webfingers,
+ domain, project_version, debug, False,
+ signing_priv_key_pem)
+ if not wf_request:
if debug:
print('DEBUG: undo announce webfinger failed for ' + handle)
return 1
- if not isinstance(wfRequest, dict):
+ if not isinstance(wf_request, dict):
print('WARN: undo announce webfinger for ' + handle +
- ' did not return a dict. ' + str(wfRequest))
+ ' did not return a dict. ' + str(wf_request))
return 1
- postToBox = 'outbox'
+ post_to_box = 'outbox'
# get the actor inbox for the To handle
- originDomain = domain
- (inboxUrl, pubKeyId, pubKey, fromPersonId,
- sharedInbox, avatarUrl,
- displayName, _) = getPersonBox(signingPrivateKeyPem,
- originDomain,
- baseDir, session, wfRequest,
- personCache,
- projectVersion, httpPrefix,
- nickname, domain,
- postToBox, 73528)
+ origin_domain = domain
+ (inbox_url, _, _, from_person_id,
+ _, _, _, _) = get_person_box(signing_priv_key_pem,
+ origin_domain,
+ base_dir, session, wf_request,
+ person_cache,
+ project_version, http_prefix,
+ nickname, domain,
+ post_to_box, 73528)
- if not inboxUrl:
+ if not inbox_url:
if debug:
- print('DEBUG: undo announce no ' + postToBox +
+ print('DEBUG: undo announce no ' + post_to_box +
' was found for ' + handle)
return 3
- if not fromPersonId:
+ if not from_person_id:
if debug:
print('DEBUG: undo announce no actor was found for ' + handle)
return 4
- authHeader = createBasicAuthHeader(nickname, password)
+ auth_header = create_basic_auth_header(nickname, password)
headers = {
'host': domain,
'Content-type': 'application/json',
- 'Authorization': authHeader
+ 'Authorization': auth_header
}
- postResult = postJson(httpPrefix, domainFull,
- session, unAnnounceJson, [], inboxUrl,
- headers, 3, True)
- if not postResult:
+ post_result = post_json(http_prefix, domain_full,
+ session, unannounce_json, [], inbox_url,
+ headers, 3, True)
+ if not post_result:
print('WARN: undo announce not posted')
if debug:
print('DEBUG: c2s POST undo announce success')
- return unAnnounceJson
+ return unannounce_json
-def outboxUndoAnnounce(recentPostsCache: {},
- baseDir: str, httpPrefix: str,
- nickname: str, domain: str, port: int,
- messageJson: {}, debug: bool) -> None:
+def outbox_undo_announce(recent_posts_cache: {},
+ base_dir: str, nickname: str, domain: str,
+ message_json: {}, debug: bool) -> None:
""" When an undo announce is received by the outbox from c2s
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
return
- if not messageJson['type'] == 'Undo':
+ if not message_json['type'] == 'Undo':
return
- if not hasObjectDict(messageJson):
- if debug:
- print('DEBUG: undo like object is not dict')
+ if not has_object_string_type(message_json, debug):
return
- if not messageJson['object'].get('type'):
- if debug:
- print('DEBUG: undo like - no type')
- return
- if not messageJson['object']['type'] == 'Announce':
+ if not message_json['object']['type'] == 'Announce':
if debug:
print('DEBUG: not a undo announce')
return
- if not messageJson['object'].get('object'):
- if debug:
- print('DEBUG: no object in undo announce')
- return
- if not isinstance(messageJson['object']['object'], str):
- if debug:
- print('DEBUG: undo announce object is not string')
+ if not has_object_string_object(message_json, debug):
return
if debug:
print('DEBUG: c2s undo announce request arrived in outbox')
- messageId = removeIdEnding(messageJson['object']['object'])
- domain = removeDomainPort(domain)
- postFilename = locatePost(baseDir, nickname, domain, messageId)
- if not postFilename:
+ message_id = remove_id_ending(message_json['object']['object'])
+ domain = remove_domain_port(domain)
+ post_filename = locate_post(base_dir, nickname, domain, message_id)
+ if not post_filename:
if debug:
print('DEBUG: c2s undo announce post not found in inbox or outbox')
- print(messageId)
+ print(message_id)
return True
- undoAnnounceCollectionEntry(recentPostsCache, baseDir, postFilename,
- messageJson['actor'], domain, debug)
+ undo_announce_collection_entry(recent_posts_cache, base_dir, post_filename,
+ message_json['actor'], domain, debug)
if debug:
- print('DEBUG: post undo announce via c2s - ' + postFilename)
+ print('DEBUG: post undo announce via c2s - ' + post_filename)
diff --git a/architecture/epicyon_groups_ActivityPub.png b/architecture/epicyon_groups_ActivityPub.png
index fb0e822e7..6dbf8724e 100644
Binary files a/architecture/epicyon_groups_ActivityPub.png and b/architecture/epicyon_groups_ActivityPub.png differ
diff --git a/architecture/epicyon_groups_ActivityPub_Core.png b/architecture/epicyon_groups_ActivityPub_Core.png
index 41efb024a..4b7a4be12 100644
Binary files a/architecture/epicyon_groups_ActivityPub_Core.png and b/architecture/epicyon_groups_ActivityPub_Core.png differ
diff --git a/architecture/epicyon_groups_ActivityPub_Security.png b/architecture/epicyon_groups_ActivityPub_Security.png
index 965224e6d..99a49ab9a 100644
Binary files a/architecture/epicyon_groups_ActivityPub_Security.png and b/architecture/epicyon_groups_ActivityPub_Security.png differ
diff --git a/architecture/epicyon_groups_Commandline-Interface_ActivityPub.png b/architecture/epicyon_groups_Commandline-Interface_ActivityPub.png
index b1551db4c..004a20293 100644
Binary files a/architecture/epicyon_groups_Commandline-Interface_ActivityPub.png and b/architecture/epicyon_groups_Commandline-Interface_ActivityPub.png differ
diff --git a/architecture/epicyon_groups_Commandline-Interface_Core.png b/architecture/epicyon_groups_Commandline-Interface_Core.png
index 3e200a7a1..8bb44e215 100644
Binary files a/architecture/epicyon_groups_Commandline-Interface_Core.png and b/architecture/epicyon_groups_Commandline-Interface_Core.png differ
diff --git a/architecture/epicyon_groups_Core.png b/architecture/epicyon_groups_Core.png
index ff28efe66..06c28b79c 100644
Binary files a/architecture/epicyon_groups_Core.png and b/architecture/epicyon_groups_Core.png differ
diff --git a/architecture/epicyon_groups_Core_Accessibility.png b/architecture/epicyon_groups_Core_Accessibility.png
index 63fd67379..b69a32978 100644
Binary files a/architecture/epicyon_groups_Core_Accessibility.png and b/architecture/epicyon_groups_Core_Accessibility.png differ
diff --git a/architecture/epicyon_groups_Core_Security.png b/architecture/epicyon_groups_Core_Security.png
index 2b53d14b7..ac81d9b66 100644
Binary files a/architecture/epicyon_groups_Core_Security.png and b/architecture/epicyon_groups_Core_Security.png differ
diff --git a/architecture/epicyon_groups_Timeline_Core.png b/architecture/epicyon_groups_Timeline_Core.png
index 4e23a02bb..e06e80c57 100644
Binary files a/architecture/epicyon_groups_Timeline_Core.png and b/architecture/epicyon_groups_Timeline_Core.png differ
diff --git a/architecture/epicyon_groups_Timeline_Security.png b/architecture/epicyon_groups_Timeline_Security.png
index 2c1193750..dcef13d2f 100644
Binary files a/architecture/epicyon_groups_Timeline_Security.png and b/architecture/epicyon_groups_Timeline_Security.png differ
diff --git a/architecture/epicyon_groups_Web-Interface-Columns_Core.png b/architecture/epicyon_groups_Web-Interface-Columns_Core.png
index 5678cf445..a1a23ed58 100644
Binary files a/architecture/epicyon_groups_Web-Interface-Columns_Core.png and b/architecture/epicyon_groups_Web-Interface-Columns_Core.png differ
diff --git a/architecture/epicyon_groups_Web-Interface_Accessibility.png b/architecture/epicyon_groups_Web-Interface_Accessibility.png
index 738fd1f73..f937f2030 100644
Binary files a/architecture/epicyon_groups_Web-Interface_Accessibility.png and b/architecture/epicyon_groups_Web-Interface_Accessibility.png differ
diff --git a/architecture/epicyon_groups_Web-Interface_Core.png b/architecture/epicyon_groups_Web-Interface_Core.png
index 9943358a9..90febf28d 100644
Binary files a/architecture/epicyon_groups_Web-Interface_Core.png and b/architecture/epicyon_groups_Web-Interface_Core.png differ
diff --git a/auth.py b/auth.py
index 0305dca68..9d67ad972 100644
--- a/auth.py
+++ b/auth.py
@@ -1,7 +1,7 @@
__filename__ = "auth.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
@@ -13,11 +13,13 @@ import binascii
import os
import secrets
import datetime
-from utils import isSystemAccount
-from utils import hasUsersPath
+from utils import is_system_account
+from utils import has_users_path
+from utils import text_in_file
+from utils import remove_eol
-def _hashPassword(password: str) -> str:
+def _hash_password(password: str) -> str:
"""Hash a password for storing
"""
salt = hashlib.sha256(os.urandom(60)).hexdigest().encode('ascii')
@@ -28,17 +30,17 @@ def _hashPassword(password: str) -> str:
return (salt + pwdhash).decode('ascii')
-def _getPasswordHash(salt: str, providedPassword: str) -> str:
+def _get_password_hash(salt: str, provided_password: str) -> str:
"""Returns the hash of a password
"""
pwdhash = hashlib.pbkdf2_hmac('sha512',
- providedPassword.encode('utf-8'),
+ provided_password.encode('utf-8'),
salt.encode('ascii'),
100000)
return binascii.hexlify(pwdhash).decode('ascii')
-def constantTimeStringCheck(string1: str, string2: str) -> bool:
+def constant_time_string_check(string1: str, string2: str) -> bool:
"""Compares two string and returns if they are the same
using a constant amount of time
See https://sqreen.github.io/DevelopersSecurityBestPractices/
@@ -49,8 +51,8 @@ def constantTimeStringCheck(string1: str, string2: str) -> bool:
return False
ctr = 0
matched = True
- for ch in string1:
- if ch != string2[ctr]:
+ for char in string1:
+ if char != string2[ctr]:
matched = False
else:
# this is to make the timing more even
@@ -60,199 +62,244 @@ def constantTimeStringCheck(string1: str, string2: str) -> bool:
return matched
-def _verifyPassword(storedPassword: str, providedPassword: str) -> bool:
+def _verify_password(stored_password: str, provided_password: str) -> bool:
"""Verify a stored password against one provided by user
"""
- if not storedPassword:
+ if not stored_password:
return False
- if not providedPassword:
+ if not provided_password:
return False
- salt = storedPassword[:64]
- storedPassword = storedPassword[64:]
- pwHash = _getPasswordHash(salt, providedPassword)
- return constantTimeStringCheck(pwHash, storedPassword)
+ salt = stored_password[:64]
+ stored_password = stored_password[64:]
+ pw_hash = _get_password_hash(salt, provided_password)
+ return constant_time_string_check(pw_hash, stored_password)
-def createBasicAuthHeader(nickname: str, password: str) -> str:
+def create_basic_auth_header(nickname: str, password: str) -> str:
"""This is only used by tests
"""
- authStr = \
- nickname.replace('\n', '').replace('\r', '') + \
+ auth_str = \
+ remove_eol(nickname) + \
':' + \
- password.replace('\n', '').replace('\r', '')
- return 'Basic ' + base64.b64encode(authStr.encode('utf-8')).decode('utf-8')
+ remove_eol(password)
+ return 'Basic ' + \
+ base64.b64encode(auth_str.encode('utf-8')).decode('utf-8')
-def authorizeBasic(baseDir: str, path: str, authHeader: str,
- debug: bool) -> bool:
+def authorize_basic(base_dir: str, path: str, auth_header: str,
+ debug: bool) -> bool:
"""HTTP basic auth
"""
- if ' ' not in authHeader:
+ if ' ' not in auth_header:
if debug:
print('DEBUG: basic auth - Authorisation header does not ' +
'contain a space character')
return False
- if not hasUsersPath(path):
- if debug:
- print('DEBUG: basic auth - ' +
- 'path for Authorization does not contain a user')
- return False
- pathUsersSection = path.split('/users/')[1]
- if '/' not in pathUsersSection:
- if debug:
- print('DEBUG: basic auth - this is not a users endpoint')
- return False
- nicknameFromPath = pathUsersSection.split('/')[0]
- if isSystemAccount(nicknameFromPath):
+ if not has_users_path(path):
+ if not path.startswith('/calendars/'):
+ if debug:
+ print('DEBUG: basic auth - ' +
+ 'path for Authorization does not contain a user')
+ return False
+ if path.startswith('/calendars/'):
+ path_users_section = path.split('/calendars/')[1]
+ nickname_from_path = path_users_section
+ if '/' in nickname_from_path:
+ nickname_from_path = nickname_from_path.split('/')[0]
+ if '?' in nickname_from_path:
+ nickname_from_path = nickname_from_path.split('?')[0]
+ else:
+ path_users_section = path.split('/users/')[1]
+ if '/' not in path_users_section:
+ if debug:
+ print('DEBUG: basic auth - this is not a users endpoint')
+ return False
+ nickname_from_path = path_users_section.split('/')[0]
+ if is_system_account(nickname_from_path):
print('basic auth - attempted login using system account ' +
- nicknameFromPath + ' in path')
+ nickname_from_path + ' in path')
return False
- base64Str = \
- authHeader.split(' ')[1].replace('\n', '').replace('\r', '')
- plain = base64.b64decode(base64Str).decode('utf-8')
+ base64_str1 = auth_header.split(' ')[1]
+ base64_str = remove_eol(base64_str1)
+ plain = base64.b64decode(base64_str).decode('utf-8')
if ':' not in plain:
if debug:
print('DEBUG: basic auth header does not contain a ":" ' +
'separator for username:password')
return False
nickname = plain.split(':')[0]
- if isSystemAccount(nickname):
+ if is_system_account(nickname):
print('basic auth - attempted login using system account ' + nickname +
' in Auth header')
return False
- if nickname != nicknameFromPath:
+ if nickname != nickname_from_path:
if debug:
- print('DEBUG: Nickname given in the path (' + nicknameFromPath +
+ print('DEBUG: Nickname given in the path (' + nickname_from_path +
') does not match the one in the Authorization header (' +
nickname + ')')
return False
- passwordFile = baseDir + '/accounts/passwords'
- if not os.path.isfile(passwordFile):
+ password_file = base_dir + '/accounts/passwords'
+ if not os.path.isfile(password_file):
if debug:
print('DEBUG: passwords file missing')
return False
- providedPassword = plain.split(':')[1]
- with open(passwordFile, 'r') as passfile:
- for line in passfile:
- if not line.startswith(nickname + ':'):
- continue
- storedPassword = \
- line.split(':')[1].replace('\n', '').replace('\r', '')
- success = _verifyPassword(storedPassword, providedPassword)
- if not success:
- if debug:
- print('DEBUG: Password check failed for ' + nickname)
- return success
+ provided_password = plain.split(':')[1]
+ try:
+ with open(password_file, 'r', encoding='utf-8') as passfile:
+ for line in passfile:
+ if not line.startswith(nickname + ':'):
+ continue
+ stored_password_base = line.split(':')[1]
+ stored_password = remove_eol(stored_password_base)
+ success = _verify_password(stored_password, provided_password)
+ if not success:
+ if debug:
+ print('DEBUG: Password check failed for ' + nickname)
+ return success
+ except OSError:
+ print('EX: failed to open password file')
+ return False
print('DEBUG: Did not find credentials for ' + nickname +
- ' in ' + passwordFile)
+ ' in ' + password_file)
return False
-def storeBasicCredentials(baseDir: str, nickname: str, password: str) -> bool:
+def store_basic_credentials(base_dir: str,
+ nickname: str, password: str) -> bool:
"""Stores login credentials to a file
"""
if ':' in nickname or ':' in password:
return False
- nickname = nickname.replace('\n', '').replace('\r', '').strip()
- password = password.replace('\n', '').replace('\r', '').strip()
+ nickname = remove_eol(nickname).strip()
+ password = remove_eol(password).strip()
- if not os.path.isdir(baseDir + '/accounts'):
- os.mkdir(baseDir + '/accounts')
+ if not os.path.isdir(base_dir + '/accounts'):
+ os.mkdir(base_dir + '/accounts')
- passwordFile = baseDir + '/accounts/passwords'
- storeStr = nickname + ':' + _hashPassword(password)
- if os.path.isfile(passwordFile):
- if nickname + ':' in open(passwordFile).read():
- with open(passwordFile, 'r') as fin:
- with open(passwordFile + '.new', 'w+') as fout:
- for line in fin:
- if not line.startswith(nickname + ':'):
- fout.write(line)
- else:
- fout.write(storeStr + '\n')
- os.rename(passwordFile + '.new', passwordFile)
+ password_file = base_dir + '/accounts/passwords'
+ store_str = nickname + ':' + _hash_password(password)
+ if os.path.isfile(password_file):
+ if text_in_file(nickname + ':', password_file):
+ try:
+ with open(password_file, 'r', encoding='utf-8') as fin:
+ with open(password_file + '.new', 'w+',
+ encoding='utf-8') as fout:
+ for line in fin:
+ if not line.startswith(nickname + ':'):
+ fout.write(line)
+ else:
+ fout.write(store_str + '\n')
+ except OSError as ex:
+ print('EX: unable to save password ' + password_file +
+ ' ' + str(ex))
+ return False
+
+ try:
+ os.rename(password_file + '.new', password_file)
+ except OSError:
+ print('EX: unable to save password 2')
+ return False
else:
# append to password file
- with open(passwordFile, 'a+') as passfile:
- passfile.write(storeStr + '\n')
+ try:
+ with open(password_file, 'a+', encoding='utf-8') as passfile:
+ passfile.write(store_str + '\n')
+ except OSError:
+ print('EX: unable to append password')
+ return False
else:
- with open(passwordFile, 'w+') as passfile:
- passfile.write(storeStr + '\n')
+ try:
+ with open(password_file, 'w+', encoding='utf-8') as passfile:
+ passfile.write(store_str + '\n')
+ except OSError:
+ print('EX: unable to create password file')
+ return False
return True
-def removePassword(baseDir: str, nickname: str) -> None:
+def remove_password(base_dir: str, nickname: str) -> None:
"""Removes the password entry for the given nickname
This is called during account removal
"""
- passwordFile = baseDir + '/accounts/passwords'
- if os.path.isfile(passwordFile):
- with open(passwordFile, 'r') as fin:
- with open(passwordFile + '.new', 'w+') as fout:
- for line in fin:
- if not line.startswith(nickname + ':'):
- fout.write(line)
- os.rename(passwordFile + '.new', passwordFile)
+ password_file = base_dir + '/accounts/passwords'
+ if os.path.isfile(password_file):
+ try:
+ with open(password_file, 'r', encoding='utf-8') as fin:
+ with open(password_file + '.new', 'w+',
+ encoding='utf-8') as fout:
+ for line in fin:
+ if not line.startswith(nickname + ':'):
+ fout.write(line)
+ except OSError as ex:
+ print('EX: unable to remove password from file ' + str(ex))
+ return
+
+ try:
+ os.rename(password_file + '.new', password_file)
+ except OSError:
+ print('EX: unable to remove password from file 2')
+ return
-def authorize(baseDir: str, path: str, authHeader: str, debug: bool) -> bool:
+def authorize(base_dir: str, path: str, auth_header: str, debug: bool) -> bool:
"""Authorize using http header
"""
- if authHeader.lower().startswith('basic '):
- return authorizeBasic(baseDir, path, authHeader, debug)
+ if auth_header.lower().startswith('basic '):
+ return authorize_basic(base_dir, path, auth_header, debug)
return False
-def createPassword(length: int = 10):
- validChars = 'abcdefghijklmnopqrstuvwxyz' + \
+def create_password(length: int):
+ valid_chars = 'abcdefghijklmnopqrstuvwxyz' + \
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
- return ''.join((secrets.choice(validChars) for i in range(length)))
+ return ''.join((secrets.choice(valid_chars) for i in range(length)))
-def recordLoginFailure(baseDir: str, ipAddress: str,
- countDict: {}, failTime: int,
- logToFile: bool) -> None:
+def record_login_failure(base_dir: str, ip_address: str,
+ count_dict: {}, fail_time: int,
+ log_to_file: bool) -> None:
"""Keeps ip addresses and the number of times login failures
occured for them in a dict
"""
- if not countDict.get(ipAddress):
- while len(countDict.items()) > 100:
- oldestTime = 0
- oldestIP = None
- for ipAddr, ipItem in countDict.items():
- if oldestTime == 0 or ipItem['time'] < oldestTime:
- oldestTime = ipItem['time']
- oldestIP = ipAddr
- if oldestIP:
- del countDict[oldestIP]
- countDict[ipAddress] = {
+ if not count_dict.get(ip_address):
+ while len(count_dict.items()) > 100:
+ oldest_time = 0
+ oldest_ip = None
+ for ip_addr, ip_item in count_dict.items():
+ if oldest_time == 0 or ip_item['time'] < oldest_time:
+ oldest_time = ip_item['time']
+ oldest_ip = ip_addr
+ if oldest_ip:
+ del count_dict[oldest_ip]
+ count_dict[ip_address] = {
"count": 1,
- "time": failTime
+ "time": fail_time
}
else:
- countDict[ipAddress]['count'] += 1
- countDict[ipAddress]['time'] = failTime
- failCount = countDict[ipAddress]['count']
- if failCount > 4:
- print('WARN: ' + str(ipAddress) + ' failed to log in ' +
- str(failCount) + ' times')
+ count_dict[ip_address]['count'] += 1
+ count_dict[ip_address]['time'] = fail_time
+ fail_count = count_dict[ip_address]['count']
+ if fail_count > 4:
+ print('WARN: ' + str(ip_address) + ' failed to log in ' +
+ str(fail_count) + ' times')
- if not logToFile:
+ if not log_to_file:
return
- failureLog = baseDir + '/accounts/loginfailures.log'
- writeType = 'a+'
- if not os.path.isfile(failureLog):
- writeType = 'w+'
- currTime = datetime.datetime.utcnow()
+ failure_log = base_dir + '/accounts/loginfailures.log'
+ write_type = 'a+'
+ if not os.path.isfile(failure_log):
+ write_type = 'w+'
+ curr_time = datetime.datetime.utcnow()
+ curr_time_str = curr_time.strftime("%Y-%m-%d %H:%M:%SZ")
try:
- with open(failureLog, writeType) as fp:
+ with open(failure_log, write_type, encoding='utf-8') as fp_fail:
# here we use a similar format to an ssh log, so that
# systems such as fail2ban can parse it
- fp.write(currTime.strftime("%Y-%m-%d %H:%M:%SZ") + ' ' +
- 'ip-127-0-0-1 sshd[20710]: ' +
- 'Disconnecting invalid user epicyon ' +
- ipAddress + ' port 443: ' +
- 'Too many authentication failures [preauth]\n')
- except BaseException:
- pass
+ fp_fail.write(curr_time_str + ' ' +
+ 'ip-127-0-0-1 sshd[20710]: ' +
+ 'Disconnecting invalid user epicyon ' +
+ ip_address + ' port 443: ' +
+ 'Too many authentication failures [preauth]\n')
+ except OSError:
+ print('EX: record_login_failure failed ' + str(failure_log))
diff --git a/availability.py b/availability.py
index ee6c2d5d6..fdb913749 100644
--- a/availability.py
+++ b/availability.py
@@ -1,160 +1,162 @@
__filename__ = "availability.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
__module_group__ = "Profile Metadata"
import os
-from webfinger import webfingerHandle
-from auth import createBasicAuthHeader
-from posts import getPersonBox
-from session import postJson
-from utils import getFullDomain
-from utils import getNicknameFromActor
-from utils import getDomainFromActor
-from utils import loadJson
-from utils import saveJson
-from utils import acctDir
-from utils import localActorUrl
+from webfinger import webfinger_handle
+from auth import create_basic_auth_header
+from posts import get_person_box
+from session import post_json
+from utils import has_object_string
+from utils import get_full_domain
+from utils import get_nickname_from_actor
+from utils import get_domain_from_actor
+from utils import load_json
+from utils import save_json
+from utils import acct_dir
+from utils import local_actor_url
+from utils import has_actor
-def setAvailability(baseDir: str, nickname: str, domain: str,
- status: str) -> bool:
+def set_availability(base_dir: str, nickname: str, domain: str,
+ status: str) -> bool:
"""Set an availability status
"""
# avoid giant strings
if len(status) > 128:
return False
- actorFilename = acctDir(baseDir, nickname, domain) + '.json'
- if not os.path.isfile(actorFilename):
+ actor_filename = acct_dir(base_dir, nickname, domain) + '.json'
+ if not os.path.isfile(actor_filename):
return False
- actorJson = loadJson(actorFilename)
- if actorJson:
- actorJson['availability'] = status
- saveJson(actorJson, actorFilename)
+ actor_json = load_json(actor_filename)
+ if actor_json:
+ actor_json['availability'] = status
+ save_json(actor_json, actor_filename)
return True
-def getAvailability(baseDir: str, nickname: str, domain: str) -> str:
+def get_availability(base_dir: str, nickname: str, domain: str) -> str:
"""Returns the availability for a given person
"""
- actorFilename = acctDir(baseDir, nickname, domain) + '.json'
- if not os.path.isfile(actorFilename):
+ actor_filename = acct_dir(base_dir, nickname, domain) + '.json'
+ if not os.path.isfile(actor_filename):
return False
- actorJson = loadJson(actorFilename)
- if actorJson:
- if not actorJson.get('availability'):
+ actor_json = load_json(actor_filename)
+ if actor_json:
+ if not actor_json.get('availability'):
return None
- return actorJson['availability']
+ return actor_json['availability']
return None
-def outboxAvailability(baseDir: str, nickname: str, messageJson: {},
- debug: bool) -> bool:
+def outbox_availability(base_dir: str, nickname: str, message_json: {},
+ debug: bool) -> bool:
"""Handles receiving an availability update
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
return False
- if not messageJson['type'] == 'Availability':
+ if not message_json['type'] == 'Availability':
return False
- if not messageJson.get('actor'):
+ if not has_actor(message_json, debug):
return False
- if not messageJson.get('object'):
- return False
- if not isinstance(messageJson['object'], str):
+ if not has_object_string(message_json, debug):
return False
- actorNickname = getNicknameFromActor(messageJson['actor'])
- if actorNickname != nickname:
+ actor_nickname = get_nickname_from_actor(message_json['actor'])
+ if not actor_nickname:
return False
- domain, port = getDomainFromActor(messageJson['actor'])
- status = messageJson['object'].replace('"', '')
+ if actor_nickname != nickname:
+ return False
+ domain, _ = get_domain_from_actor(message_json['actor'])
+ status = message_json['object'].replace('"', '')
- return setAvailability(baseDir, nickname, domain, status)
+ return set_availability(base_dir, nickname, domain, status)
-def sendAvailabilityViaServer(baseDir: str, session,
- nickname: str, password: str,
- domain: str, port: int,
- httpPrefix: str,
- status: str,
- cachedWebfingers: {}, personCache: {},
- debug: bool, projectVersion: str,
- signingPrivateKeyPem: str) -> {}:
+def send_availability_via_server(base_dir: str, session,
+ nickname: str, password: str,
+ domain: str, port: int,
+ http_prefix: str,
+ status: str,
+ cached_webfingers: {}, person_cache: {},
+ debug: bool, project_version: str,
+ signing_priv_key_pem: str) -> {}:
"""Sets the availability for a person via c2s
"""
if not session:
- print('WARN: No session for sendAvailabilityViaServer')
+ print('WARN: No session for send_availability_via_server')
return 6
- domainFull = getFullDomain(domain, port)
+ domain_full = get_full_domain(domain, port)
- toUrl = localActorUrl(httpPrefix, nickname, domainFull)
- ccUrl = toUrl + '/followers'
+ to_url = local_actor_url(http_prefix, nickname, domain_full)
+ cc_url = to_url + '/followers'
- newAvailabilityJson = {
+ new_availability_json = {
'type': 'Availability',
- 'actor': toUrl,
+ 'actor': to_url,
'object': '"' + status + '"',
- 'to': [toUrl],
- 'cc': [ccUrl]
+ 'to': [to_url],
+ 'cc': [cc_url]
}
- handle = httpPrefix + '://' + domainFull + '/@' + nickname
+ handle = http_prefix + '://' + domain_full + '/@' + nickname
# lookup the inbox for the To handle
- wfRequest = webfingerHandle(session, handle, httpPrefix,
- cachedWebfingers,
- domain, projectVersion, debug, False,
- signingPrivateKeyPem)
- if not wfRequest:
+ wf_request = webfinger_handle(session, handle, http_prefix,
+ cached_webfingers,
+ domain, project_version, debug, False,
+ signing_priv_key_pem)
+ if not wf_request:
if debug:
print('DEBUG: availability webfinger failed for ' + handle)
return 1
- if not isinstance(wfRequest, dict):
+ if not isinstance(wf_request, dict):
print('WARN: availability webfinger for ' + handle +
- ' did not return a dict. ' + str(wfRequest))
+ ' did not return a dict. ' + str(wf_request))
return 1
- postToBox = 'outbox'
+ post_to_box = 'outbox'
# get the actor inbox for the To handle
- originDomain = domain
- (inboxUrl, pubKeyId, pubKey, fromPersonId, sharedInbox, avatarUrl,
- displayName, _) = getPersonBox(signingPrivateKeyPem,
- originDomain,
- baseDir, session, wfRequest,
- personCache, projectVersion,
- httpPrefix, nickname,
- domain, postToBox, 57262)
+ origin_domain = domain
+ (inbox_url, _, _, from_person_id, _, _,
+ _, _) = get_person_box(signing_priv_key_pem,
+ origin_domain,
+ base_dir, session, wf_request,
+ person_cache, project_version,
+ http_prefix, nickname,
+ domain, post_to_box, 57262)
- if not inboxUrl:
+ if not inbox_url:
if debug:
- print('DEBUG: availability no ' + postToBox +
+ print('DEBUG: availability no ' + post_to_box +
' was found for ' + handle)
return 3
- if not fromPersonId:
+ if not from_person_id:
if debug:
print('DEBUG: availability no actor was found for ' + handle)
return 4
- authHeader = createBasicAuthHeader(nickname, password)
+ auth_header = create_basic_auth_header(nickname, password)
headers = {
'host': domain,
'Content-type': 'application/json',
- 'Authorization': authHeader
+ 'Authorization': auth_header
}
- postResult = postJson(httpPrefix, domainFull,
- session, newAvailabilityJson, [],
- inboxUrl, headers, 30, True)
- if not postResult:
+ post_result = post_json(http_prefix, domain_full,
+ session, new_availability_json, [],
+ inbox_url, headers, 30, True)
+ if not post_result:
print('WARN: availability failed to post')
if debug:
print('DEBUG: c2s POST availability success')
- return newAvailabilityJson
+ return new_availability_json
diff --git a/blocking.py b/blocking.py
index ddfb688c6..aea6a5d02 100644
--- a/blocking.py
+++ b/blocking.py
@@ -1,7 +1,7 @@
__filename__ = "blocking.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
@@ -11,490 +11,570 @@ import os
import json
import time
from datetime import datetime
-from utils import removeDomainPort
-from utils import hasObjectDict
-from utils import isAccountDir
-from utils import getCachedPostFilename
-from utils import loadJson
-from utils import saveJson
-from utils import fileLastModified
-from utils import setConfigParam
-from utils import hasUsersPath
-from utils import getFullDomain
-from utils import removeIdEnding
-from utils import isEvil
-from utils import locatePost
-from utils import evilIncarnate
-from utils import getDomainFromActor
-from utils import getNicknameFromActor
-from utils import acctDir
-from utils import localActorUrl
-from conversation import muteConversation
-from conversation import unmuteConversation
+from utils import remove_eol
+from utils import has_object_string
+from utils import has_object_string_object
+from utils import has_object_string_type
+from utils import remove_domain_port
+from utils import has_object_dict
+from utils import is_account_dir
+from utils import get_cached_post_filename
+from utils import load_json
+from utils import save_json
+from utils import file_last_modified
+from utils import set_config_param
+from utils import has_users_path
+from utils import get_full_domain
+from utils import remove_id_ending
+from utils import is_evil
+from utils import locate_post
+from utils import evil_incarnate
+from utils import get_domain_from_actor
+from utils import get_nickname_from_actor
+from utils import acct_dir
+from utils import local_actor_url
+from utils import has_actor
+from utils import text_in_file
+from conversation import mute_conversation
+from conversation import unmute_conversation
-def addGlobalBlock(baseDir: str,
- blockNickname: str, blockDomain: str) -> bool:
+def add_global_block(base_dir: str,
+ block_nickname: str, block_domain: str) -> bool:
"""Global block which applies to all accounts
"""
- blockingFilename = baseDir + '/accounts/blocking.txt'
- if not blockNickname.startswith('#'):
+ blocking_filename = base_dir + '/accounts/blocking.txt'
+ if not block_nickname.startswith('#'):
# is the handle already blocked?
- blockHandle = blockNickname + '@' + blockDomain
- if os.path.isfile(blockingFilename):
- if blockHandle in open(blockingFilename).read():
+ block_handle = block_nickname + '@' + block_domain
+ if os.path.isfile(blocking_filename):
+ if text_in_file(block_handle, blocking_filename):
return False
# block an account handle or domain
- with open(blockingFilename, 'a+') as blockFile:
- blockFile.write(blockHandle + '\n')
+ try:
+ with open(blocking_filename, 'a+', encoding='utf-8') as block_file:
+ block_file.write(block_handle + '\n')
+ except OSError:
+ print('EX: unable to save blocked handle ' + block_handle)
+ return False
else:
- blockHashtag = blockNickname
+ block_hashtag = block_nickname
# is the hashtag already blocked?
- if os.path.isfile(blockingFilename):
- if blockHashtag + '\n' in open(blockingFilename).read():
+ if os.path.isfile(blocking_filename):
+ if text_in_file(block_hashtag + '\n', blocking_filename):
return False
# block a hashtag
- with open(blockingFilename, 'a+') as blockFile:
- blockFile.write(blockHashtag + '\n')
+ try:
+ with open(blocking_filename, 'a+', encoding='utf-8') as block_file:
+ block_file.write(block_hashtag + '\n')
+ except OSError:
+ print('EX: unable to save blocked hashtag ' + block_hashtag)
+ return False
return True
-def addBlock(baseDir: str, nickname: str, domain: str,
- blockNickname: str, blockDomain: str) -> bool:
+def add_block(base_dir: str, nickname: str, domain: str,
+ block_nickname: str, block_domain: str) -> bool:
"""Block the given account
"""
- if blockDomain.startswith(domain) and nickname == blockNickname:
+ if block_domain.startswith(domain) and nickname == block_nickname:
# don't block self
return False
- domain = removeDomainPort(domain)
- blockingFilename = acctDir(baseDir, nickname, domain) + '/blocking.txt'
- blockHandle = blockNickname + '@' + blockDomain
- if os.path.isfile(blockingFilename):
- if blockHandle + '\n' in open(blockingFilename).read():
+ domain = remove_domain_port(domain)
+ blocking_filename = acct_dir(base_dir, nickname, domain) + '/blocking.txt'
+ block_handle = block_nickname + '@' + block_domain
+ if os.path.isfile(blocking_filename):
+ if text_in_file(block_handle + '\n', blocking_filename):
return False
# if we are following then unfollow
- followingFilename = acctDir(baseDir, nickname, domain) + '/following.txt'
- if os.path.isfile(followingFilename):
- if blockHandle + '\n' in open(followingFilename).read():
- followingStr = ''
- with open(followingFilename, 'r') as followingFile:
- followingStr = followingFile.read()
- followingStr = followingStr.replace(blockHandle + '\n', '')
- with open(followingFilename, 'w+') as followingFile:
- followingFile.write(followingStr)
+ following_filename = \
+ acct_dir(base_dir, nickname, domain) + '/following.txt'
+ if os.path.isfile(following_filename):
+ if text_in_file(block_handle + '\n', following_filename):
+ following_str = ''
+ try:
+ with open(following_filename, 'r',
+ encoding='utf-8') as foll_file:
+ following_str = foll_file.read()
+ except OSError:
+ print('EX: Unable to read following ' + following_filename)
+ return False
+
+ if following_str:
+ following_str = following_str.replace(block_handle + '\n', '')
+
+ try:
+ with open(following_filename, 'w+',
+ encoding='utf-8') as foll_file:
+ foll_file.write(following_str)
+ except OSError:
+ print('EX: Unable to write following ' + following_str)
+ return False
# if they are a follower then remove them
- followersFilename = acctDir(baseDir, nickname, domain) + '/followers.txt'
- if os.path.isfile(followersFilename):
- if blockHandle + '\n' in open(followersFilename).read():
- followersStr = ''
- with open(followersFilename, 'r') as followersFile:
- followersStr = followersFile.read()
- followersStr = followersStr.replace(blockHandle + '\n', '')
- with open(followersFilename, 'w+') as followersFile:
- followersFile.write(followersStr)
+ followers_filename = \
+ acct_dir(base_dir, nickname, domain) + '/followers.txt'
+ if os.path.isfile(followers_filename):
+ if text_in_file(block_handle + '\n', followers_filename):
+ followers_str = ''
+ try:
+ with open(followers_filename, 'r',
+ encoding='utf-8') as foll_file:
+ followers_str = foll_file.read()
+ except OSError:
+ print('EX: Unable to read followers ' + followers_filename)
+ return False
- with open(blockingFilename, 'a+') as blockFile:
- blockFile.write(blockHandle + '\n')
+ if followers_str:
+ followers_str = followers_str.replace(block_handle + '\n', '')
+
+ try:
+ with open(followers_filename, 'w+',
+ encoding='utf-8') as foll_file:
+ foll_file.write(followers_str)
+ except OSError:
+ print('EX: Unable to write followers ' + followers_str)
+ return False
+
+ try:
+ with open(blocking_filename, 'a+', encoding='utf-8') as block_file:
+ block_file.write(block_handle + '\n')
+ except OSError:
+ print('EX: unable to append block handle ' + block_handle)
+ return False
return True
-def removeGlobalBlock(baseDir: str,
- unblockNickname: str,
- unblockDomain: str) -> bool:
+def remove_global_block(base_dir: str,
+ unblock_nickname: str,
+ unblock_domain: str) -> bool:
"""Unblock the given global block
"""
- unblockingFilename = baseDir + '/accounts/blocking.txt'
- if not unblockNickname.startswith('#'):
- unblockHandle = unblockNickname + '@' + unblockDomain
- if os.path.isfile(unblockingFilename):
- if unblockHandle in open(unblockingFilename).read():
- with open(unblockingFilename, 'r') as fp:
- with open(unblockingFilename + '.new', 'w+') as fpnew:
- for line in fp:
- handle = line.replace('\n', '').replace('\r', '')
- if unblockHandle not in line:
- fpnew.write(handle + '\n')
- if os.path.isfile(unblockingFilename + '.new'):
- os.rename(unblockingFilename + '.new', unblockingFilename)
+ unblocking_filename = base_dir + '/accounts/blocking.txt'
+ if not unblock_nickname.startswith('#'):
+ unblock_handle = unblock_nickname + '@' + unblock_domain
+ if os.path.isfile(unblocking_filename):
+ if text_in_file(unblock_handle, unblocking_filename):
+ try:
+ with open(unblocking_filename, 'r',
+ encoding='utf-8') as fp_unblock:
+ with open(unblocking_filename + '.new', 'w+',
+ encoding='utf-8') as fpnew:
+ for line in fp_unblock:
+ handle = remove_eol(line)
+ if unblock_handle not in line:
+ fpnew.write(handle + '\n')
+ except OSError as ex:
+ print('EX: failed to remove global block ' +
+ unblocking_filename + ' ' + str(ex))
+ return False
+
+ if os.path.isfile(unblocking_filename + '.new'):
+ try:
+ os.rename(unblocking_filename + '.new',
+ unblocking_filename)
+ except OSError:
+ print('EX: unable to rename ' + unblocking_filename)
+ return False
return True
else:
- unblockHashtag = unblockNickname
- if os.path.isfile(unblockingFilename):
- if unblockHashtag + '\n' in open(unblockingFilename).read():
- with open(unblockingFilename, 'r') as fp:
- with open(unblockingFilename + '.new', 'w+') as fpnew:
- for line in fp:
- blockLine = \
- line.replace('\n', '').replace('\r', '')
- if unblockHashtag not in line:
- fpnew.write(blockLine + '\n')
- if os.path.isfile(unblockingFilename + '.new'):
- os.rename(unblockingFilename + '.new', unblockingFilename)
+ unblock_hashtag = unblock_nickname
+ if os.path.isfile(unblocking_filename):
+ if text_in_file(unblock_hashtag + '\n', unblocking_filename):
+ try:
+ with open(unblocking_filename, 'r',
+ encoding='utf-8') as fp_unblock:
+ with open(unblocking_filename + '.new', 'w+',
+ encoding='utf-8') as fpnew:
+ for line in fp_unblock:
+ block_line = remove_eol(line)
+ if unblock_hashtag not in line:
+ fpnew.write(block_line + '\n')
+ except OSError as ex:
+ print('EX: failed to remove global hashtag block ' +
+ unblocking_filename + ' ' + str(ex))
+ return False
+
+ if os.path.isfile(unblocking_filename + '.new'):
+ try:
+ os.rename(unblocking_filename + '.new',
+ unblocking_filename)
+ except OSError:
+ print('EX: unable to rename 2 ' + unblocking_filename)
+ return False
return True
return False
-def removeBlock(baseDir: str, nickname: str, domain: str,
- unblockNickname: str, unblockDomain: str) -> bool:
+def remove_block(base_dir: str, nickname: str, domain: str,
+ unblock_nickname: str, unblock_domain: str) -> bool:
"""Unblock the given account
"""
- domain = removeDomainPort(domain)
- unblockingFilename = acctDir(baseDir, nickname, domain) + '/blocking.txt'
- unblockHandle = unblockNickname + '@' + unblockDomain
- if os.path.isfile(unblockingFilename):
- if unblockHandle in open(unblockingFilename).read():
- with open(unblockingFilename, 'r') as fp:
- with open(unblockingFilename + '.new', 'w+') as fpnew:
- for line in fp:
- handle = line.replace('\n', '').replace('\r', '')
- if unblockHandle not in line:
- fpnew.write(handle + '\n')
- if os.path.isfile(unblockingFilename + '.new'):
- os.rename(unblockingFilename + '.new', unblockingFilename)
+ domain = remove_domain_port(domain)
+ unblocking_filename = \
+ acct_dir(base_dir, nickname, domain) + '/blocking.txt'
+ unblock_handle = unblock_nickname + '@' + unblock_domain
+ if os.path.isfile(unblocking_filename):
+ if text_in_file(unblock_handle, unblocking_filename):
+ try:
+ with open(unblocking_filename, 'r',
+ encoding='utf-8') as fp_unblock:
+ with open(unblocking_filename + '.new', 'w+',
+ encoding='utf-8') as fpnew:
+ for line in fp_unblock:
+ handle = remove_eol(line)
+ if unblock_handle not in line:
+ fpnew.write(handle + '\n')
+ except OSError as ex:
+ print('EX: failed to remove block ' +
+ unblocking_filename + ' ' + str(ex))
+ return False
+
+ if os.path.isfile(unblocking_filename + '.new'):
+ try:
+ os.rename(unblocking_filename + '.new',
+ unblocking_filename)
+ except OSError:
+ print('EX: unable to rename 3 ' + unblocking_filename)
+ return False
return True
return False
-def isBlockedHashtag(baseDir: str, hashtag: str) -> bool:
+def is_blocked_hashtag(base_dir: str, hashtag: str) -> bool:
"""Is the given hashtag blocked?
"""
# avoid very long hashtags
if len(hashtag) > 32:
return True
- globalBlockingFilename = baseDir + '/accounts/blocking.txt'
- if os.path.isfile(globalBlockingFilename):
+ global_blocking_filename = base_dir + '/accounts/blocking.txt'
+ if os.path.isfile(global_blocking_filename):
hashtag = hashtag.strip('\n').strip('\r')
if not hashtag.startswith('#'):
hashtag = '#' + hashtag
- if hashtag + '\n' in open(globalBlockingFilename).read():
+ if text_in_file(hashtag + '\n', global_blocking_filename):
return True
return False
-def getDomainBlocklist(baseDir: str) -> str:
+def get_domain_blocklist(base_dir: str) -> str:
"""Returns all globally blocked domains as a string
This can be used for fast matching to mitigate flooding
"""
- blockedStr = ''
+ blocked_str = ''
- evilDomains = evilIncarnate()
- for evil in evilDomains:
- blockedStr += evil + '\n'
+ evil_domains = evil_incarnate()
+ for evil in evil_domains:
+ blocked_str += evil + '\n'
- globalBlockingFilename = baseDir + '/accounts/blocking.txt'
- if not os.path.isfile(globalBlockingFilename):
- return blockedStr
- with open(globalBlockingFilename, 'r') as fpBlocked:
- blockedStr += fpBlocked.read()
- return blockedStr
+ global_blocking_filename = base_dir + '/accounts/blocking.txt'
+ if not os.path.isfile(global_blocking_filename):
+ return blocked_str
+ try:
+ with open(global_blocking_filename, 'r',
+ encoding='utf-8') as fp_blocked:
+ blocked_str += fp_blocked.read()
+ except OSError:
+ print('EX: unable to read ' + global_blocking_filename)
+ return blocked_str
-def updateBlockedCache(baseDir: str,
- blockedCache: [],
- blockedCacheLastUpdated: int,
- blockedCacheUpdateSecs: int) -> int:
+def update_blocked_cache(base_dir: str,
+ blocked_cache: [],
+ blocked_cache_last_updated: int,
+ blocked_cache_update_secs: int) -> int:
"""Updates the cache of globally blocked domains held in memory
"""
- currTime = int(time.time())
- if blockedCacheLastUpdated > currTime:
+ curr_time = int(time.time())
+ if blocked_cache_last_updated > curr_time:
print('WARN: Cache updated in the future')
- blockedCacheLastUpdated = 0
- secondsSinceLastUpdate = currTime - blockedCacheLastUpdated
- if secondsSinceLastUpdate < blockedCacheUpdateSecs:
- return blockedCacheLastUpdated
- globalBlockingFilename = baseDir + '/accounts/blocking.txt'
- if not os.path.isfile(globalBlockingFilename):
- return blockedCacheLastUpdated
- with open(globalBlockingFilename, 'r') as fpBlocked:
- blockedLines = fpBlocked.readlines()
- # remove newlines
- for index in range(len(blockedLines)):
- blockedLines[index] = blockedLines[index].replace('\n', '')
- # update the cache
- blockedCache.clear()
- blockedCache += blockedLines
- return currTime
+ blocked_cache_last_updated = 0
+ seconds_since_last_update = curr_time - blocked_cache_last_updated
+ if seconds_since_last_update < blocked_cache_update_secs:
+ return blocked_cache_last_updated
+ global_blocking_filename = base_dir + '/accounts/blocking.txt'
+ if not os.path.isfile(global_blocking_filename):
+ return blocked_cache_last_updated
+ try:
+ with open(global_blocking_filename, 'r',
+ encoding='utf-8') as fp_blocked:
+ blocked_lines = fp_blocked.readlines()
+ # remove newlines
+ for index, _ in enumerate(blocked_lines):
+ blocked_lines[index] = remove_eol(blocked_lines[index])
+ # update the cache
+ blocked_cache.clear()
+ blocked_cache += blocked_lines
+ except OSError as ex:
+ print('EX: unable to read ' + global_blocking_filename + ' ' + str(ex))
+ return curr_time
-def _getShortDomain(domain: str) -> str:
+def _get_short_domain(domain: str) -> str:
""" by checking a shorter version we can thwart adversaries
who constantly change their subdomain
e.g. subdomain123.mydomain.com becomes mydomain.com
"""
sections = domain.split('.')
- noOfSections = len(sections)
- if noOfSections > 2:
- return sections[noOfSections-2] + '.' + sections[-1]
+ no_of_sections = len(sections)
+ if no_of_sections > 2:
+ return sections[no_of_sections-2] + '.' + sections[-1]
return None
-def isBlockedDomain(baseDir: str, domain: str,
- blockedCache: [] = None) -> bool:
+def is_blocked_domain(base_dir: str, domain: str,
+ blocked_cache: [] = None) -> bool:
"""Is the given domain blocked?
"""
if '.' not in domain:
return False
- if isEvil(domain):
+ if is_evil(domain):
return True
- shortDomain = _getShortDomain(domain)
+ short_domain = _get_short_domain(domain)
- if not brochModeIsActive(baseDir):
- if blockedCache:
- for blockedStr in blockedCache:
- if '*@' + domain in blockedStr:
+ if not broch_mode_is_active(base_dir):
+ if blocked_cache:
+ for blocked_str in blocked_cache:
+ if blocked_str == '*@' + domain:
return True
- if shortDomain:
- if '*@' + shortDomain in blockedStr:
+ if short_domain:
+ if blocked_str == '*@' + short_domain:
return True
else:
# instance block list
- globalBlockingFilename = baseDir + '/accounts/blocking.txt'
- if os.path.isfile(globalBlockingFilename):
- with open(globalBlockingFilename, 'r') as fpBlocked:
- blockedStr = fpBlocked.read()
- if '*@' + domain in blockedStr:
- return True
- if shortDomain:
- if '*@' + shortDomain in blockedStr:
+ global_blocking_filename = base_dir + '/accounts/blocking.txt'
+ if os.path.isfile(global_blocking_filename):
+ try:
+ with open(global_blocking_filename, 'r',
+ encoding='utf-8') as fp_blocked:
+ blocked_str = fp_blocked.read()
+ if '*@' + domain + '\n' in blocked_str:
return True
+ if short_domain:
+ if '*@' + short_domain + '\n' in blocked_str:
+ return True
+ except OSError as ex:
+ print('EX: unable to read ' + global_blocking_filename +
+ ' ' + str(ex))
else:
- allowFilename = baseDir + '/accounts/allowedinstances.txt'
+ allow_filename = base_dir + '/accounts/allowedinstances.txt'
# instance allow list
- if not shortDomain:
- if domain not in open(allowFilename).read():
+ if not short_domain:
+ if not text_in_file(domain, allow_filename):
return True
else:
- if shortDomain not in open(allowFilename).read():
+ if not text_in_file(short_domain, allow_filename):
return True
return False
-def isBlocked(baseDir: str, nickname: str, domain: str,
- blockNickname: str, blockDomain: str,
- blockedCache: [] = None) -> bool:
+def is_blocked(base_dir: str, nickname: str, domain: str,
+ block_nickname: str, block_domain: str,
+ blocked_cache: [] = None) -> bool:
"""Is the given nickname blocked?
"""
- if isEvil(blockDomain):
+ if is_evil(block_domain):
return True
- blockHandle = None
- if blockNickname and blockDomain:
- blockHandle = blockNickname + '@' + blockDomain
+ block_handle = None
+ if block_nickname and block_domain:
+ block_handle = block_nickname + '@' + block_domain
- if not brochModeIsActive(baseDir):
+ if not broch_mode_is_active(base_dir):
# instance level block list
- if blockedCache:
- for blockedStr in blockedCache:
- if '*@' + domain in blockedStr:
+ if blocked_cache:
+ for blocked_str in blocked_cache:
+ if '*@' + domain in blocked_str:
return True
- if blockHandle:
- if blockHandle in blockedStr:
+ if block_handle:
+ if blocked_str == block_handle:
return True
else:
- globalBlockingFilename = baseDir + '/accounts/blocking.txt'
- if os.path.isfile(globalBlockingFilename):
- if '*@' + blockDomain in open(globalBlockingFilename).read():
+ global_blocks_filename = base_dir + '/accounts/blocking.txt'
+ if os.path.isfile(global_blocks_filename):
+ if text_in_file('*@' + block_domain, global_blocks_filename):
return True
- if blockHandle:
- if blockHandle in open(globalBlockingFilename).read():
+ if block_handle:
+ block_str = block_handle + '\n'
+ if text_in_file(block_str, global_blocks_filename):
return True
else:
# instance allow list
- allowFilename = baseDir + '/accounts/allowedinstances.txt'
- shortDomain = _getShortDomain(blockDomain)
- if not shortDomain:
- if blockDomain not in open(allowFilename).read():
+ allow_filename = base_dir + '/accounts/allowedinstances.txt'
+ short_domain = _get_short_domain(block_domain)
+ if not short_domain:
+ if not text_in_file(block_domain + '\n', allow_filename):
return True
else:
- if shortDomain not in open(allowFilename).read():
+ if not text_in_file(short_domain + '\n', allow_filename):
return True
# account level allow list
- accountDir = acctDir(baseDir, nickname, domain)
- allowFilename = accountDir + '/allowedinstances.txt'
- if os.path.isfile(allowFilename):
- if blockDomain not in open(allowFilename).read():
+ account_dir = acct_dir(base_dir, nickname, domain)
+ allow_filename = account_dir + '/allowedinstances.txt'
+ if os.path.isfile(allow_filename):
+ if not text_in_file(block_domain + '\n', allow_filename):
return True
# account level block list
- blockingFilename = accountDir + '/blocking.txt'
- if os.path.isfile(blockingFilename):
- if '*@' + blockDomain in open(blockingFilename).read():
+ blocking_filename = account_dir + '/blocking.txt'
+ if os.path.isfile(blocking_filename):
+ if text_in_file('*@' + block_domain + '\n', blocking_filename):
return True
- if blockHandle:
- if blockHandle in open(blockingFilename).read():
+ if block_handle:
+ if text_in_file(block_handle + '\n', blocking_filename):
return True
return False
-def outboxBlock(baseDir: str, httpPrefix: str,
- nickname: str, domain: str, port: int,
- messageJson: {}, debug: bool) -> bool:
+def outbox_block(base_dir: str, nickname: str, domain: str,
+ message_json: {}, debug: bool) -> bool:
""" When a block request is received by the outbox from c2s
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
if debug:
print('DEBUG: block - no type')
return False
- if not messageJson['type'] == 'Block':
+ if not message_json['type'] == 'Block':
if debug:
print('DEBUG: not a block')
return False
- if not messageJson.get('object'):
- if debug:
- print('DEBUG: no object in block')
- return False
- if not isinstance(messageJson['object'], str):
- if debug:
- print('DEBUG: block object is not string')
+ if not has_object_string(message_json, debug):
return False
if debug:
print('DEBUG: c2s block request arrived in outbox')
- messageId = removeIdEnding(messageJson['object'])
- if '/statuses/' not in messageId:
+ message_id = remove_id_ending(message_json['object'])
+ if '/statuses/' not in message_id:
if debug:
print('DEBUG: c2s block object is not a status')
return False
- if not hasUsersPath(messageId):
+ if not has_users_path(message_id):
if debug:
print('DEBUG: c2s block object has no nickname')
return False
- domain = removeDomainPort(domain)
- postFilename = locatePost(baseDir, nickname, domain, messageId)
- if not postFilename:
+ domain = remove_domain_port(domain)
+ post_filename = locate_post(base_dir, nickname, domain, message_id)
+ if not post_filename:
if debug:
print('DEBUG: c2s block post not found in inbox or outbox')
- print(messageId)
+ print(message_id)
return False
- nicknameBlocked = getNicknameFromActor(messageJson['object'])
- if not nicknameBlocked:
- print('WARN: unable to find nickname in ' + messageJson['object'])
+ nickname_blocked = get_nickname_from_actor(message_json['object'])
+ if not nickname_blocked:
+ print('WARN: unable to find nickname in ' + message_json['object'])
return False
- domainBlocked, portBlocked = getDomainFromActor(messageJson['object'])
- domainBlockedFull = getFullDomain(domainBlocked, portBlocked)
+ domain_blocked, port_blocked = \
+ get_domain_from_actor(message_json['object'])
+ domain_blocked_full = get_full_domain(domain_blocked, port_blocked)
- addBlock(baseDir, nickname, domain,
- nicknameBlocked, domainBlockedFull)
+ add_block(base_dir, nickname, domain,
+ nickname_blocked, domain_blocked_full)
if debug:
- print('DEBUG: post blocked via c2s - ' + postFilename)
+ print('DEBUG: post blocked via c2s - ' + post_filename)
return True
-def outboxUndoBlock(baseDir: str, httpPrefix: str,
- nickname: str, domain: str, port: int,
- messageJson: {}, debug: bool) -> None:
+def outbox_undo_block(base_dir: str, nickname: str, domain: str,
+ message_json: {}, debug: bool) -> None:
""" When an undo block request is received by the outbox from c2s
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
if debug:
print('DEBUG: undo block - no type')
return
- if not messageJson['type'] == 'Undo':
+ if not message_json['type'] == 'Undo':
if debug:
print('DEBUG: not an undo block')
return
- if not hasObjectDict(messageJson):
- if debug:
- print('DEBUG: undo block object is not string')
- return
- if not messageJson['object'].get('type'):
- if debug:
- print('DEBUG: undo block - no type')
+ if not has_object_string_type(message_json, debug):
return
- if not messageJson['object']['type'] == 'Block':
+ if not message_json['object']['type'] == 'Block':
if debug:
print('DEBUG: not an undo block')
return
- if not messageJson['object'].get('object'):
- if debug:
- print('DEBUG: no object in undo block')
- return
- if not isinstance(messageJson['object']['object'], str):
- if debug:
- print('DEBUG: undo block object is not string')
+ if not has_object_string_object(message_json, debug):
return
if debug:
print('DEBUG: c2s undo block request arrived in outbox')
- messageId = removeIdEnding(messageJson['object']['object'])
- if '/statuses/' not in messageId:
+ message_id = remove_id_ending(message_json['object']['object'])
+ if '/statuses/' not in message_id:
if debug:
print('DEBUG: c2s undo block object is not a status')
return
- if not hasUsersPath(messageId):
+ if not has_users_path(message_id):
if debug:
print('DEBUG: c2s undo block object has no nickname')
return
- domain = removeDomainPort(domain)
- postFilename = locatePost(baseDir, nickname, domain, messageId)
- if not postFilename:
+ domain = remove_domain_port(domain)
+ post_filename = locate_post(base_dir, nickname, domain, message_id)
+ if not post_filename:
if debug:
print('DEBUG: c2s undo block post not found in inbox or outbox')
- print(messageId)
+ print(message_id)
return
- nicknameBlocked = getNicknameFromActor(messageJson['object']['object'])
- if not nicknameBlocked:
+ nickname_blocked = \
+ get_nickname_from_actor(message_json['object']['object'])
+ if not nickname_blocked:
print('WARN: unable to find nickname in ' +
- messageJson['object']['object'])
+ message_json['object']['object'])
return
- domainObject = messageJson['object']['object']
- domainBlocked, portBlocked = getDomainFromActor(domainObject)
- domainBlockedFull = getFullDomain(domainBlocked, portBlocked)
+ domain_object = message_json['object']['object']
+ domain_blocked, port_blocked = get_domain_from_actor(domain_object)
+ domain_blocked_full = get_full_domain(domain_blocked, port_blocked)
- removeBlock(baseDir, nickname, domain,
- nicknameBlocked, domainBlockedFull)
+ remove_block(base_dir, nickname, domain,
+ nickname_blocked, domain_blocked_full)
if debug:
- print('DEBUG: post undo blocked via c2s - ' + postFilename)
+ print('DEBUG: post undo blocked via c2s - ' + post_filename)
-def mutePost(baseDir: str, nickname: str, domain: str, port: int,
- httpPrefix: str, postId: str, recentPostsCache: {},
- debug: bool) -> None:
+def mute_post(base_dir: str, nickname: str, domain: str, port: int,
+ http_prefix: str, post_id: str, recent_posts_cache: {},
+ debug: bool) -> None:
""" Mutes the given post
"""
- print('mutePost: postId ' + postId)
- postFilename = locatePost(baseDir, nickname, domain, postId)
- if not postFilename:
- print('mutePost: file not found ' + postId)
+ print('mute_post: post_id ' + post_id)
+ post_filename = locate_post(base_dir, nickname, domain, post_id)
+ if not post_filename:
+ print('mute_post: file not found ' + post_id)
return
- postJsonObject = loadJson(postFilename)
- if not postJsonObject:
- print('mutePost: object not loaded ' + postId)
+ post_json_object = load_json(post_filename)
+ if not post_json_object:
+ print('mute_post: object not loaded ' + post_id)
return
- print('mutePost: ' + str(postJsonObject))
+ print('mute_post: ' + str(post_json_object))
- postJsonObj = postJsonObject
- alsoUpdatePostId = None
- if hasObjectDict(postJsonObject):
- postJsonObj = postJsonObject['object']
+ post_json_obj = post_json_object
+ also_update_post_id = None
+ if has_object_dict(post_json_object):
+ post_json_obj = post_json_object['object']
else:
- if postJsonObject.get('object'):
- if isinstance(postJsonObject['object'], str):
- alsoUpdatePostId = removeIdEnding(postJsonObject['object'])
+ if has_object_string(post_json_object, debug):
+ also_update_post_id = remove_id_ending(post_json_object['object'])
- domainFull = getFullDomain(domain, port)
- actor = localActorUrl(httpPrefix, nickname, domainFull)
+ domain_full = get_full_domain(domain, port)
+ actor = local_actor_url(http_prefix, nickname, domain_full)
- if postJsonObj.get('conversation'):
- muteConversation(baseDir, nickname, domain,
- postJsonObj['conversation'])
+ if post_json_obj.get('conversation'):
+ mute_conversation(base_dir, nickname, domain,
+ post_json_obj['conversation'])
# does this post have ignores on it from differenent actors?
- if not postJsonObj.get('ignores'):
+ if not post_json_obj.get('ignores'):
if debug:
- print('DEBUG: Adding initial mute to ' + postId)
- ignoresJson = {
+ print('DEBUG: Adding initial mute to ' + post_id)
+ ignores_json = {
"@context": "https://www.w3.org/ns/activitystreams",
- 'id': postId,
+ 'id': post_id,
'type': 'Collection',
"totalItems": 1,
'items': [{
@@ -502,316 +582,326 @@ def mutePost(baseDir: str, nickname: str, domain: str, port: int,
'actor': actor
}]
}
- postJsonObj['ignores'] = ignoresJson
+ post_json_obj['ignores'] = ignores_json
else:
- if not postJsonObj['ignores'].get('items'):
- postJsonObj['ignores']['items'] = []
- itemsList = postJsonObj['ignores']['items']
- for ignoresItem in itemsList:
- if ignoresItem.get('actor'):
- if ignoresItem['actor'] == actor:
+ if not post_json_obj['ignores'].get('items'):
+ post_json_obj['ignores']['items'] = []
+ items_list = post_json_obj['ignores']['items']
+ for ignores_item in items_list:
+ if ignores_item.get('actor'):
+ if ignores_item['actor'] == actor:
return
- newIgnore = {
+ new_ignore = {
'type': 'Ignore',
'actor': actor
}
- igIt = len(itemsList)
- itemsList.append(newIgnore)
- postJsonObj['ignores']['totalItems'] = igIt
- postJsonObj['muted'] = True
- if saveJson(postJsonObject, postFilename):
- print('mutePost: saved ' + postFilename)
+ ig_it = len(items_list)
+ items_list.append(new_ignore)
+ post_json_obj['ignores']['totalItems'] = ig_it
+ post_json_obj['muted'] = True
+ if save_json(post_json_object, post_filename):
+ print('mute_post: saved ' + post_filename)
# remove cached post so that the muted version gets recreated
# without its content text and/or image
- cachedPostFilename = \
- getCachedPostFilename(baseDir, nickname, domain, postJsonObject)
- if cachedPostFilename:
- if os.path.isfile(cachedPostFilename):
+ cached_post_filename = \
+ get_cached_post_filename(base_dir, nickname, domain, post_json_object)
+ if cached_post_filename:
+ if os.path.isfile(cached_post_filename):
try:
- os.remove(cachedPostFilename)
- print('MUTE: cached post removed ' + cachedPostFilename)
- except BaseException:
- pass
+ os.remove(cached_post_filename)
+ print('MUTE: cached post removed ' + cached_post_filename)
+ except OSError:
+ print('EX: MUTE cached post not removed ' +
+ cached_post_filename)
else:
- print('MUTE: cached post not found ' + cachedPostFilename)
+ print('MUTE: cached post not found ' + cached_post_filename)
- with open(postFilename + '.muted', 'w+') as muteFile:
- muteFile.write('\n')
- print('MUTE: ' + postFilename + '.muted file added')
+ try:
+ with open(post_filename + '.muted', 'w+',
+ encoding='utf-8') as mute_file:
+ mute_file.write('\n')
+ except OSError:
+ print('EX: Failed to save mute file ' + post_filename + '.muted')
+ return
+ print('MUTE: ' + post_filename + '.muted file added')
# if the post is in the recent posts cache then mark it as muted
- if recentPostsCache.get('index'):
- postId = \
- removeIdEnding(postJsonObject['id']).replace('/', '#')
- if postId in recentPostsCache['index']:
- print('MUTE: ' + postId + ' is in recent posts cache')
- if recentPostsCache.get('json'):
- recentPostsCache['json'][postId] = json.dumps(postJsonObject)
- print('MUTE: ' + postId +
+ if recent_posts_cache.get('index'):
+ post_id = \
+ remove_id_ending(post_json_object['id']).replace('/', '#')
+ if post_id in recent_posts_cache['index']:
+ print('MUTE: ' + post_id + ' is in recent posts cache')
+ if recent_posts_cache.get('json'):
+ recent_posts_cache['json'][post_id] = json.dumps(post_json_object)
+ print('MUTE: ' + post_id +
' marked as muted in recent posts memory cache')
- if recentPostsCache.get('html'):
- if recentPostsCache['html'].get(postId):
- del recentPostsCache['html'][postId]
- print('MUTE: ' + postId + ' removed cached html')
+ if recent_posts_cache.get('html'):
+ if recent_posts_cache['html'].get(post_id):
+ del recent_posts_cache['html'][post_id]
+ print('MUTE: ' + post_id + ' removed cached html')
- if alsoUpdatePostId:
- postFilename = locatePost(baseDir, nickname, domain, alsoUpdatePostId)
- if os.path.isfile(postFilename):
- postJsonObj = loadJson(postFilename)
- cachedPostFilename = \
- getCachedPostFilename(baseDir, nickname, domain,
- postJsonObj)
- if cachedPostFilename:
- if os.path.isfile(cachedPostFilename):
+ if also_update_post_id:
+ post_filename = locate_post(base_dir, nickname, domain,
+ also_update_post_id)
+ if os.path.isfile(post_filename):
+ post_json_obj = load_json(post_filename)
+ cached_post_filename = \
+ get_cached_post_filename(base_dir, nickname, domain,
+ post_json_obj)
+ if cached_post_filename:
+ if os.path.isfile(cached_post_filename):
try:
- os.remove(cachedPostFilename)
+ os.remove(cached_post_filename)
print('MUTE: cached referenced post removed ' +
- cachedPostFilename)
- except BaseException:
- pass
+ cached_post_filename)
+ except OSError:
+ print('EX: ' +
+ 'MUTE cached referenced post not removed ' +
+ cached_post_filename)
- if recentPostsCache.get('json'):
- if recentPostsCache['json'].get(alsoUpdatePostId):
- del recentPostsCache['json'][alsoUpdatePostId]
- print('MUTE: ' + alsoUpdatePostId + ' removed referenced json')
- if recentPostsCache.get('html'):
- if recentPostsCache['html'].get(alsoUpdatePostId):
- del recentPostsCache['html'][alsoUpdatePostId]
- print('MUTE: ' + alsoUpdatePostId + ' removed referenced html')
+ if recent_posts_cache.get('json'):
+ if recent_posts_cache['json'].get(also_update_post_id):
+ del recent_posts_cache['json'][also_update_post_id]
+ print('MUTE: ' + also_update_post_id +
+ ' removed referenced json')
+ if recent_posts_cache.get('html'):
+ if recent_posts_cache['html'].get(also_update_post_id):
+ del recent_posts_cache['html'][also_update_post_id]
+ print('MUTE: ' + also_update_post_id +
+ ' removed referenced html')
-def unmutePost(baseDir: str, nickname: str, domain: str, port: int,
- httpPrefix: str, postId: str, recentPostsCache: {},
- debug: bool) -> None:
+def unmute_post(base_dir: str, nickname: str, domain: str, port: int,
+ http_prefix: str, post_id: str, recent_posts_cache: {},
+ debug: bool) -> None:
""" Unmutes the given post
"""
- postFilename = locatePost(baseDir, nickname, domain, postId)
- if not postFilename:
+ post_filename = locate_post(base_dir, nickname, domain, post_id)
+ if not post_filename:
return
- postJsonObject = loadJson(postFilename)
- if not postJsonObject:
+ post_json_object = load_json(post_filename)
+ if not post_json_object:
return
- muteFilename = postFilename + '.muted'
- if os.path.isfile(muteFilename):
+ mute_filename = post_filename + '.muted'
+ if os.path.isfile(mute_filename):
try:
- os.remove(muteFilename)
- except BaseException:
- pass
- print('UNMUTE: ' + muteFilename + ' file removed')
+ os.remove(mute_filename)
+ except OSError:
+ if debug:
+ print('EX: unmute_post mute filename not deleted ' +
+ str(mute_filename))
+ print('UNMUTE: ' + mute_filename + ' file removed')
- postJsonObj = postJsonObject
- alsoUpdatePostId = None
- if hasObjectDict(postJsonObject):
- postJsonObj = postJsonObject['object']
+ post_json_obj = post_json_object
+ also_update_post_id = None
+ if has_object_dict(post_json_object):
+ post_json_obj = post_json_object['object']
else:
- if postJsonObject.get('object'):
- if isinstance(postJsonObject['object'], str):
- alsoUpdatePostId = removeIdEnding(postJsonObject['object'])
+ if has_object_string(post_json_object, debug):
+ also_update_post_id = remove_id_ending(post_json_object['object'])
- if postJsonObj.get('conversation'):
- unmuteConversation(baseDir, nickname, domain,
- postJsonObj['conversation'])
+ if post_json_obj.get('conversation'):
+ unmute_conversation(base_dir, nickname, domain,
+ post_json_obj['conversation'])
- if postJsonObj.get('ignores'):
- domainFull = getFullDomain(domain, port)
- actor = localActorUrl(httpPrefix, nickname, domainFull)
- totalItems = 0
- if postJsonObj['ignores'].get('totalItems'):
- totalItems = postJsonObj['ignores']['totalItems']
- itemsList = postJsonObj['ignores']['items']
- for ignoresItem in itemsList:
- if ignoresItem.get('actor'):
- if ignoresItem['actor'] == actor:
+ if post_json_obj.get('ignores'):
+ domain_full = get_full_domain(domain, port)
+ actor = local_actor_url(http_prefix, nickname, domain_full)
+ total_items = 0
+ if post_json_obj['ignores'].get('totalItems'):
+ total_items = post_json_obj['ignores']['totalItems']
+ items_list = post_json_obj['ignores']['items']
+ for ignores_item in items_list:
+ if ignores_item.get('actor'):
+ if ignores_item['actor'] == actor:
if debug:
print('DEBUG: mute was removed for ' + actor)
- itemsList.remove(ignoresItem)
+ items_list.remove(ignores_item)
break
- if totalItems == 1:
+ if total_items == 1:
if debug:
print('DEBUG: mute was removed from post')
- del postJsonObj['ignores']
+ del post_json_obj['ignores']
else:
- igItLen = len(postJsonObj['ignores']['items'])
- postJsonObj['ignores']['totalItems'] = igItLen
- postJsonObj['muted'] = False
- saveJson(postJsonObject, postFilename)
+ ig_it_len = len(post_json_obj['ignores']['items'])
+ post_json_obj['ignores']['totalItems'] = ig_it_len
+ post_json_obj['muted'] = False
+ save_json(post_json_object, post_filename)
# remove cached post so that the muted version gets recreated
# with its content text and/or image
- cachedPostFilename = \
- getCachedPostFilename(baseDir, nickname, domain, postJsonObject)
- if cachedPostFilename:
- if os.path.isfile(cachedPostFilename):
+ cached_post_filename = \
+ get_cached_post_filename(base_dir, nickname, domain, post_json_object)
+ if cached_post_filename:
+ if os.path.isfile(cached_post_filename):
try:
- os.remove(cachedPostFilename)
- except BaseException:
- pass
+ os.remove(cached_post_filename)
+ except OSError:
+ if debug:
+ print('EX: unmute_post cached post not deleted ' +
+ str(cached_post_filename))
# if the post is in the recent posts cache then mark it as unmuted
- if recentPostsCache.get('index'):
- postId = \
- removeIdEnding(postJsonObject['id']).replace('/', '#')
- if postId in recentPostsCache['index']:
- print('UNMUTE: ' + postId + ' is in recent posts cache')
- if recentPostsCache.get('json'):
- recentPostsCache['json'][postId] = json.dumps(postJsonObject)
- print('UNMUTE: ' + postId +
+ if recent_posts_cache.get('index'):
+ post_id = \
+ remove_id_ending(post_json_object['id']).replace('/', '#')
+ if post_id in recent_posts_cache['index']:
+ print('UNMUTE: ' + post_id + ' is in recent posts cache')
+ if recent_posts_cache.get('json'):
+ recent_posts_cache['json'][post_id] = json.dumps(post_json_object)
+ print('UNMUTE: ' + post_id +
' marked as unmuted in recent posts cache')
- if recentPostsCache.get('html'):
- if recentPostsCache['html'].get(postId):
- del recentPostsCache['html'][postId]
- print('UNMUTE: ' + postId + ' removed cached html')
- if alsoUpdatePostId:
- postFilename = locatePost(baseDir, nickname, domain, alsoUpdatePostId)
- if os.path.isfile(postFilename):
- postJsonObj = loadJson(postFilename)
- cachedPostFilename = \
- getCachedPostFilename(baseDir, nickname, domain,
- postJsonObj)
- if cachedPostFilename:
- if os.path.isfile(cachedPostFilename):
+ if recent_posts_cache.get('html'):
+ if recent_posts_cache['html'].get(post_id):
+ del recent_posts_cache['html'][post_id]
+ print('UNMUTE: ' + post_id + ' removed cached html')
+ if also_update_post_id:
+ post_filename = locate_post(base_dir, nickname, domain,
+ also_update_post_id)
+ if os.path.isfile(post_filename):
+ post_json_obj = load_json(post_filename)
+ cached_post_filename = \
+ get_cached_post_filename(base_dir, nickname, domain,
+ post_json_obj)
+ if cached_post_filename:
+ if os.path.isfile(cached_post_filename):
try:
- os.remove(cachedPostFilename)
+ os.remove(cached_post_filename)
print('MUTE: cached referenced post removed ' +
- cachedPostFilename)
- except BaseException:
- pass
+ cached_post_filename)
+ except OSError:
+ if debug:
+ print('EX: ' +
+ 'unmute_post cached ref post not removed ' +
+ str(cached_post_filename))
- if recentPostsCache.get('json'):
- if recentPostsCache['json'].get(alsoUpdatePostId):
- del recentPostsCache['json'][alsoUpdatePostId]
+ if recent_posts_cache.get('json'):
+ if recent_posts_cache['json'].get(also_update_post_id):
+ del recent_posts_cache['json'][also_update_post_id]
print('UNMUTE: ' +
- alsoUpdatePostId + ' removed referenced json')
- if recentPostsCache.get('html'):
- if recentPostsCache['html'].get(alsoUpdatePostId):
- del recentPostsCache['html'][alsoUpdatePostId]
+ also_update_post_id + ' removed referenced json')
+ if recent_posts_cache.get('html'):
+ if recent_posts_cache['html'].get(also_update_post_id):
+ del recent_posts_cache['html'][also_update_post_id]
print('UNMUTE: ' +
- alsoUpdatePostId + ' removed referenced html')
+ also_update_post_id + ' removed referenced html')
-def outboxMute(baseDir: str, httpPrefix: str,
- nickname: str, domain: str, port: int,
- messageJson: {}, debug: bool,
- recentPostsCache: {}) -> None:
+def outbox_mute(base_dir: str, http_prefix: str,
+ nickname: str, domain: str, port: int,
+ message_json: {}, debug: bool,
+ recent_posts_cache: {}) -> None:
"""When a mute is received by the outbox from c2s
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
return
- if not messageJson.get('actor'):
+ if not has_actor(message_json, debug):
return
- domainFull = getFullDomain(domain, port)
- if not messageJson['actor'].endswith(domainFull + '/users/' + nickname):
+ domain_full = get_full_domain(domain, port)
+ if not message_json['actor'].endswith(domain_full + '/users/' + nickname):
return
- if not messageJson['type'] == 'Ignore':
+ if not message_json['type'] == 'Ignore':
return
- if not messageJson.get('object'):
- if debug:
- print('DEBUG: no object in mute')
- return
- if not isinstance(messageJson['object'], str):
- if debug:
- print('DEBUG: mute object is not string')
+ if not has_object_string(message_json, debug):
return
if debug:
print('DEBUG: c2s mute request arrived in outbox')
- messageId = removeIdEnding(messageJson['object'])
- if '/statuses/' not in messageId:
+ message_id = remove_id_ending(message_json['object'])
+ if '/statuses/' not in message_id:
if debug:
print('DEBUG: c2s mute object is not a status')
return
- if not hasUsersPath(messageId):
+ if not has_users_path(message_id):
if debug:
print('DEBUG: c2s mute object has no nickname')
return
- domain = removeDomainPort(domain)
- postFilename = locatePost(baseDir, nickname, domain, messageId)
- if not postFilename:
+ domain = remove_domain_port(domain)
+ post_filename = locate_post(base_dir, nickname, domain, message_id)
+ if not post_filename:
if debug:
print('DEBUG: c2s mute post not found in inbox or outbox')
- print(messageId)
+ print(message_id)
return
- nicknameMuted = getNicknameFromActor(messageJson['object'])
- if not nicknameMuted:
- print('WARN: unable to find nickname in ' + messageJson['object'])
+ nickname_muted = get_nickname_from_actor(message_json['object'])
+ if not nickname_muted:
+ print('WARN: unable to find nickname in ' + message_json['object'])
return
- mutePost(baseDir, nickname, domain, port,
- httpPrefix, messageJson['object'], recentPostsCache,
- debug)
+ mute_post(base_dir, nickname, domain, port,
+ http_prefix, message_json['object'], recent_posts_cache,
+ debug)
if debug:
- print('DEBUG: post muted via c2s - ' + postFilename)
+ print('DEBUG: post muted via c2s - ' + post_filename)
-def outboxUndoMute(baseDir: str, httpPrefix: str,
- nickname: str, domain: str, port: int,
- messageJson: {}, debug: bool,
- recentPostsCache: {}) -> None:
+def outbox_undo_mute(base_dir: str, http_prefix: str,
+ nickname: str, domain: str, port: int,
+ message_json: {}, debug: bool,
+ recent_posts_cache: {}) -> None:
"""When an undo mute is received by the outbox from c2s
"""
- if not messageJson.get('type'):
+ if not message_json.get('type'):
return
- if not messageJson.get('actor'):
+ if not has_actor(message_json, debug):
return
- domainFull = getFullDomain(domain, port)
- if not messageJson['actor'].endswith(domainFull + '/users/' + nickname):
+ domain_full = get_full_domain(domain, port)
+ if not message_json['actor'].endswith(domain_full + '/users/' + nickname):
return
- if not messageJson['type'] == 'Undo':
+ if not message_json['type'] == 'Undo':
return
- if not hasObjectDict(messageJson):
+ if not has_object_string_type(message_json, debug):
return
- if not messageJson['object'].get('type'):
+ if message_json['object']['type'] != 'Ignore':
return
- if messageJson['object']['type'] != 'Ignore':
- return
- if not isinstance(messageJson['object']['object'], str):
+ if not isinstance(message_json['object']['object'], str):
if debug:
print('DEBUG: undo mute object is not a string')
return
if debug:
print('DEBUG: c2s undo mute request arrived in outbox')
- messageId = removeIdEnding(messageJson['object']['object'])
- if '/statuses/' not in messageId:
+ message_id = remove_id_ending(message_json['object']['object'])
+ if '/statuses/' not in message_id:
if debug:
print('DEBUG: c2s undo mute object is not a status')
return
- if not hasUsersPath(messageId):
+ if not has_users_path(message_id):
if debug:
print('DEBUG: c2s undo mute object has no nickname')
return
- domain = removeDomainPort(domain)
- postFilename = locatePost(baseDir, nickname, domain, messageId)
- if not postFilename:
+ domain = remove_domain_port(domain)
+ post_filename = locate_post(base_dir, nickname, domain, message_id)
+ if not post_filename:
if debug:
print('DEBUG: c2s undo mute post not found in inbox or outbox')
- print(messageId)
+ print(message_id)
return
- nicknameMuted = getNicknameFromActor(messageJson['object']['object'])
- if not nicknameMuted:
+ nickname_muted = get_nickname_from_actor(message_json['object']['object'])
+ if not nickname_muted:
print('WARN: unable to find nickname in ' +
- messageJson['object']['object'])
+ message_json['object']['object'])
return
- unmutePost(baseDir, nickname, domain, port,
- httpPrefix, messageJson['object']['object'],
- recentPostsCache, debug)
+ unmute_post(base_dir, nickname, domain, port,
+ http_prefix, message_json['object']['object'],
+ recent_posts_cache, debug)
if debug:
- print('DEBUG: post undo mute via c2s - ' + postFilename)
+ print('DEBUG: post undo mute via c2s - ' + post_filename)
-def brochModeIsActive(baseDir: str) -> bool:
+def broch_mode_is_active(base_dir: str) -> bool:
"""Returns true if broch mode is active
"""
- allowFilename = baseDir + '/accounts/allowedinstances.txt'
- return os.path.isfile(allowFilename)
+ allow_filename = base_dir + '/accounts/allowedinstances.txt'
+ return os.path.isfile(allow_filename)
-def setBrochMode(baseDir: str, domainFull: str, enabled: bool) -> None:
+def set_broch_mode(base_dir: str, domain_full: str, enabled: bool) -> None:
"""Broch mode can be used to lock down the instance during
a period of time when it is temporarily under attack.
For example, where an adversary is constantly spinning up new
@@ -820,81 +910,197 @@ def setBrochMode(baseDir: str, domainFull: str, enabled: bool) -> None:
to construct an instance level allow list. Anything arriving
which is then not from one of the allowed domains will be dropped
"""
- allowFilename = baseDir + '/accounts/allowedinstances.txt'
+ allow_filename = base_dir + '/accounts/allowedinstances.txt'
if not enabled:
# remove instance allow list
- if os.path.isfile(allowFilename):
+ if os.path.isfile(allow_filename):
try:
- os.remove(allowFilename)
- except BaseException:
- pass
+ os.remove(allow_filename)
+ except OSError:
+ print('EX: set_broch_mode allow file not deleted ' +
+ str(allow_filename))
print('Broch mode turned off')
else:
- if os.path.isfile(allowFilename):
- lastModified = fileLastModified(allowFilename)
- print('Broch mode already activated ' + lastModified)
+ if os.path.isfile(allow_filename):
+ last_modified = file_last_modified(allow_filename)
+ print('Broch mode already activated ' + last_modified)
return
# generate instance allow list
- allowedDomains = [domainFull]
- followFiles = ('following.txt', 'followers.txt')
- for subdir, dirs, files in os.walk(baseDir + '/accounts'):
+ allowed_domains = [domain_full]
+ follow_files = ('following.txt', 'followers.txt')
+ for _, dirs, _ in os.walk(base_dir + '/accounts'):
for acct in dirs:
- if not isAccountDir(acct):
+ if not is_account_dir(acct):
continue
- accountDir = os.path.join(baseDir + '/accounts', acct)
- for followFileType in followFiles:
- followingFilename = accountDir + '/' + followFileType
- if not os.path.isfile(followingFilename):
+ account_dir = os.path.join(base_dir + '/accounts', acct)
+ for follow_file_type in follow_files:
+ following_filename = account_dir + '/' + follow_file_type
+ if not os.path.isfile(following_filename):
continue
- with open(followingFilename, 'r') as f:
- followList = f.readlines()
- for handle in followList:
- if '@' not in handle:
- continue
- handle = handle.replace('\n', '')
- handleDomain = handle.split('@')[1]
- if handleDomain not in allowedDomains:
- allowedDomains.append(handleDomain)
+ try:
+ with open(following_filename, 'r',
+ encoding='utf-8') as foll_file:
+ follow_list = foll_file.readlines()
+ for handle in follow_list:
+ if '@' not in handle:
+ continue
+ handle = remove_eol(handle)
+ handle_domain = handle.split('@')[1]
+ if handle_domain not in allowed_domains:
+ allowed_domains.append(handle_domain)
+ except OSError as ex:
+ print('EX: failed to read ' + following_filename +
+ ' ' + str(ex))
break
# write the allow file
- with open(allowFilename, 'w+') as allowFile:
- allowFile.write(domainFull + '\n')
- for d in allowedDomains:
- allowFile.write(d + '\n')
- print('Broch mode enabled')
+ try:
+ with open(allow_filename, 'w+',
+ encoding='utf-8') as allow_file:
+ allow_file.write(domain_full + '\n')
+ for allowed in allowed_domains:
+ allow_file.write(allowed + '\n')
+ print('Broch mode enabled')
+ except OSError as ex:
+ print('EX: Broch mode not enabled due to file write ' + str(ex))
+ return
- setConfigParam(baseDir, "brochMode", enabled)
+ set_config_param(base_dir, "brochMode", enabled)
-def brochModeLapses(baseDir: str, lapseDays: int = 7) -> bool:
+def broch_modeLapses(base_dir: str, lapseDays: int) -> bool:
"""After broch mode is enabled it automatically
elapses after a period of time
"""
- allowFilename = baseDir + '/accounts/allowedinstances.txt'
- if not os.path.isfile(allowFilename):
+ allow_filename = base_dir + '/accounts/allowedinstances.txt'
+ if not os.path.isfile(allow_filename):
return False
- lastModified = fileLastModified(allowFilename)
- modifiedDate = None
+ last_modified = file_last_modified(allow_filename)
+ modified_date = None
try:
- modifiedDate = \
- datetime.strptime(lastModified, "%Y-%m-%dT%H:%M:%SZ")
+ modified_date = \
+ datetime.strptime(last_modified, "%Y-%m-%dT%H:%M:%SZ")
except BaseException:
+ print('EX: broch_modeLapses date not parsed ' + str(last_modified))
return False
- if not modifiedDate:
+ if not modified_date:
return False
- currTime = datetime.datetime.utcnow()
- daysSinceBroch = (currTime - modifiedDate).days
- if daysSinceBroch >= lapseDays:
+ curr_time = datetime.datetime.utcnow()
+ days_since_broch = (curr_time - modified_date).days
+ if days_since_broch >= lapseDays:
removed = False
try:
- os.remove(allowFilename)
+ os.remove(allow_filename)
removed = True
- except BaseException:
- pass
+ except OSError:
+ print('EX: broch_modeLapses allow file not deleted ' +
+ str(allow_filename))
if removed:
- setConfigParam(baseDir, "brochMode", False)
+ set_config_param(base_dir, "brochMode", False)
print('Broch mode has elapsed')
return True
return False
+
+
+def load_cw_lists(base_dir: str, verbose: bool) -> {}:
+ """Load lists used for content warnings
+ """
+ if not os.path.isdir(base_dir + '/cwlists'):
+ return {}
+ result = {}
+ # NOTE: here we do want to allow recursive walk through
+ # possible subdirectories
+ for _, _, files in os.walk(base_dir + '/cwlists'):
+ for fname in files:
+ if not fname.endswith('.json'):
+ continue
+ list_filename = os.path.join(base_dir + '/cwlists', fname)
+ print('list_filename: ' + list_filename)
+ list_json = load_json(list_filename, 0, 1)
+ if not list_json:
+ continue
+ if not list_json.get('name'):
+ continue
+ if not list_json.get('words') and not list_json.get('domains'):
+ continue
+ name = list_json['name']
+ if verbose:
+ print('List: ' + name)
+ result[name] = list_json
+ return result
+
+
+def add_cw_from_lists(post_json_object: {}, cw_lists: {}, translate: {},
+ lists_enabled: str, system_language: str) -> None:
+ """Adds content warnings by matching the post content
+ against domains or keywords
+ """
+ if not lists_enabled:
+ return
+ if not post_json_object['object'].get('content'):
+ if not post_json_object['object'].get('contentMap'):
+ return
+ cw_text = ''
+ if post_json_object['object'].get('summary'):
+ cw_text = post_json_object['object']['summary']
+
+ content = None
+ if post_json_object['object'].get('contentMap'):
+ if post_json_object['object']['contentMap'].get(system_language):
+ content = \
+ post_json_object['object']['contentMap'][system_language]
+ if not content:
+ if post_json_object['object'].get('content'):
+ content = post_json_object['object']['content']
+ if not content:
+ return
+ for name, item in cw_lists.items():
+ if name not in lists_enabled:
+ continue
+ if not item.get('warning'):
+ continue
+ warning = item['warning']
+
+ # is there a translated version of the warning?
+ if translate.get(warning):
+ warning = translate[warning]
+
+ # is the warning already in the CW?
+ if warning in cw_text:
+ continue
+
+ matched = False
+
+ # match domains within the content
+ if item.get('domains'):
+ for domain in item['domains']:
+ if domain in content:
+ if cw_text:
+ cw_text = warning + ' / ' + cw_text
+ else:
+ cw_text = warning
+ matched = True
+ break
+
+ if matched:
+ continue
+
+ # match words within the content
+ if item.get('words'):
+ for word_str in item['words']:
+ if word_str in content or word_str.title() in content:
+ if cw_text:
+ cw_text = warning + ' / ' + cw_text
+ else:
+ cw_text = warning
+ break
+ if cw_text:
+ post_json_object['object']['summary'] = cw_text
+ post_json_object['object']['sensitive'] = True
+
+
+def get_cw_list_variable(list_name: str) -> str:
+ """Returns the variable associated with a CW list
+ """
+ return 'list' + list_name.replace(' ', '').replace("'", '')
diff --git a/blog.py b/blog.py
index fbdcadad0..2ba055066 100644
--- a/blog.py
+++ b/blog.py
@@ -1,7 +1,7 @@
__filename__ = "blog.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
-__version__ = "1.2.0"
+__version__ = "1.3.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
@@ -10,403 +10,436 @@ __module_group__ = "ActivityPub"
import os
from datetime import datetime
-from content import replaceEmojiFromTags
-from webapp_utils import htmlHeaderWithExternalStyle
-from webapp_utils import htmlHeaderWithBlogMarkup
-from webapp_utils import htmlFooter
-from webapp_utils import getPostAttachmentsAsHtml
-from webapp_utils import editTextArea
-from webapp_media import addEmbeddedElements
-from utils import localActorUrl
-from utils import getActorLanguagesList
-from utils import getBaseContentFromPost
-from utils import getContentFromPost
-from utils import isAccountDir
-from utils import removeHtml
-from utils import getConfigParam
-from utils import getFullDomain
-from utils import getMediaFormats
-from utils import getNicknameFromActor
-from utils import getDomainFromActor
-from utils import locatePost
-from utils import loadJson
-from utils import firstParagraphFromString
-from utils import getActorPropertyUrl
-from utils import acctDir
-from posts import createBlogsTimeline
-from newswire import rss2Header
-from newswire import rss2Footer
-from cache import getPersonFromCache
+from content import replace_emoji_from_tags
+from webapp_utils import html_header_with_external_style
+from webapp_utils import html_header_with_blog_markup
+from webapp_utils import html_footer
+from webapp_utils import get_post_attachments_as_html
+from webapp_utils import edit_text_area
+from webapp_media import add_embedded_elements
+from utils import remove_eol
+from utils import text_in_file
+from utils import local_actor_url
+from utils import get_actor_languages_list
+from utils import get_base_content_from_post
+from utils import get_content_from_post
+from utils import is_account_dir
+from utils import remove_html
+from utils import get_config_param
+from utils import get_full_domain
+from utils import get_media_formats
+from utils import get_nickname_from_actor
+from utils import get_domain_from_actor
+from utils import locate_post
+from utils import load_json
+from utils import first_paragraph_from_string
+from utils import get_actor_property_url
+from utils import acct_dir
+from posts import create_blogs_timeline
+from newswire import rss2header
+from newswire import rss2footer
+from cache import get_person_from_cache
-def _noOfBlogReplies(baseDir: str, httpPrefix: str, translate: {},
- nickname: str, domain: str, domainFull: str,
- postId: str, depth=0) -> int:
+def _no_of_blog_replies(base_dir: str, http_prefix: str, translate: {},
+ nickname: str, domain: str, domain_full: str,
+ post_id: str, depth: int = 0) -> int:
"""Returns the number of replies on the post
This is recursive, so can handle replies to replies
"""
if depth > 4:
return 0
- if not postId:
+ if not post_id:
return 0
- tryPostBox = ('tlblogs', 'inbox', 'outbox')
- boxFound = False
- for postBox in tryPostBox:
- postFilename = \
- acctDir(baseDir, nickname, domain) + '/' + postBox + '/' + \
- postId.replace('/', '#') + '.replies'
- if os.path.isfile(postFilename):
- boxFound = True
+ try_post_box = ('tlblogs', 'inbox', 'outbox')
+ box_found = False
+ for post_box in try_post_box:
+ post_filename = \
+ acct_dir(base_dir, nickname, domain) + '/' + post_box + '/' + \
+ post_id.replace('/', '#') + '.replies'
+ if os.path.isfile(post_filename):
+ box_found = True
break
- if not boxFound:
+ if not box_found:
# post may exist but has no replies
- for postBox in tryPostBox:
- postFilename = \
- acctDir(baseDir, nickname, domain) + '/' + postBox + '/' + \
- postId.replace('/', '#')
- if os.path.isfile(postFilename):
+ for post_box in try_post_box:
+ post_filename = \
+ acct_dir(base_dir, nickname, domain) + '/' + post_box + '/' + \
+ post_id.replace('/', '#')
+ if os.path.isfile(post_filename):
return 1
return 0
removals = []
replies = 0
lines = []
- with open(postFilename, 'r') as f:
- lines = f.readlines()
- for replyPostId in lines:
- replyPostId = replyPostId.replace('\n', '').replace('\r', '')
- replyPostId = replyPostId.replace('.json', '')
- if locatePost(baseDir, nickname, domain, replyPostId):
- replyPostId = replyPostId.replace('.replies', '')
- replies += \
- 1 + _noOfBlogReplies(baseDir, httpPrefix, translate,
- nickname, domain, domainFull,
- replyPostId, depth+1)
- else:
- # remove post which no longer exists
- removals.append(replyPostId)
+ try:
+ with open(post_filename, 'r', encoding='utf-8') as post_file:
+ lines = post_file.readlines()
+ except OSError:
+ print('EX: failed to read blog ' + post_filename)
+
+ for reply_post_id in lines:
+ reply_post_id = remove_eol(reply_post_id)
+ reply_post_id = reply_post_id.replace('.json', '')
+ if locate_post(base_dir, nickname, domain, reply_post_id):
+ reply_post_id = reply_post_id.replace('.replies', '')
+ replies += \
+ 1 + _no_of_blog_replies(base_dir, http_prefix, translate,
+ nickname, domain, domain_full,
+ reply_post_id, depth+1)
+ else:
+ # remove post which no longer exists
+ removals.append(reply_post_id)
# remove posts from .replies file if they don't exist
if lines and removals:
- print('Rewriting ' + postFilename + ' to remove ' +
+ print('Rewriting ' + post_filename + ' to remove ' +
str(len(removals)) + ' entries')
- with open(postFilename, 'w+') as f:
- for replyPostId in lines:
- replyPostId = replyPostId.replace('\n', '').replace('\r', '')
- if replyPostId not in removals:
- f.write(replyPostId + '\n')
+ try:
+ with open(post_filename, 'w+', encoding='utf-8') as post_file:
+ for reply_post_id in lines:
+ reply_post_id = remove_eol(reply_post_id)
+ if reply_post_id not in removals:
+ post_file.write(reply_post_id + '\n')
+ except OSError as ex:
+ print('EX: unable to remove replies from post ' +
+ post_filename + ' ' + str(ex))
return replies
-def _getBlogReplies(baseDir: str, httpPrefix: str, translate: {},
- nickname: str, domain: str, domainFull: str,
- postId: str, depth=0) -> str:
+def _get_blog_replies(base_dir: str, http_prefix: str, translate: {},
+ nickname: str, domain: str, domain_full: str,
+ post_id: str, depth: int = 0) -> str:
"""Returns a string containing html blog posts
"""
if depth > 4:
return ''
- if not postId:
+ if not post_id:
return ''
- tryPostBox = ('tlblogs', 'inbox', 'outbox')
- boxFound = False
- for postBox in tryPostBox:
- postFilename = \
- acctDir(baseDir, nickname, domain) + '/' + postBox + '/' + \
- postId.replace('/', '#') + '.replies'
- if os.path.isfile(postFilename):
- boxFound = True
+ try_post_box = ('tlblogs', 'inbox', 'outbox')
+ box_found = False
+ for post_box in try_post_box:
+ post_filename = \
+ acct_dir(base_dir, nickname, domain) + '/' + post_box + '/' + \
+ post_id.replace('/', '#') + '.replies'
+ if os.path.isfile(post_filename):
+ box_found = True
break
- if not boxFound:
+ if not box_found:
# post may exist but has no replies
- for postBox in tryPostBox:
- postFilename = \
- acctDir(baseDir, nickname, domain) + '/' + postBox + '/' + \
- postId.replace('/', '#') + '.json'
- if os.path.isfile(postFilename):
- postFilename = acctDir(baseDir, nickname, domain) + \
+ for post_box in try_post_box:
+ post_filename = \
+ acct_dir(base_dir, nickname, domain) + '/' + post_box + '/' + \
+ post_id.replace('/', '#') + '.json'
+ if os.path.isfile(post_filename):
+ post_filename = acct_dir(base_dir, nickname, domain) + \
'/postcache/' + \
- postId.replace('/', '#') + '.html'
- if os.path.isfile(postFilename):
- with open(postFilename, 'r') as postFile:
- return postFile.read() + '\n'
+ post_id.replace('/', '#') + '.html'
+ if os.path.isfile(post_filename):
+ try:
+ with open(post_filename, 'r',
+ encoding='utf-8') as post_file:
+ return post_file.read() + '\n'
+ except OSError:
+ print('EX: unable to read blog 3 ' + post_filename)
return ''
- with open(postFilename, 'r') as f:
- lines = f.readlines()
- repliesStr = ''
- for replyPostId in lines:
- replyPostId = replyPostId.replace('\n', '').replace('\r', '')
- replyPostId = replyPostId.replace('.json', '')
- replyPostId = replyPostId.replace('.replies', '')
- postFilename = acctDir(baseDir, nickname, domain) + \
+ lines = []
+ try:
+ with open(post_filename, 'r', encoding='utf-8') as post_file:
+ lines = post_file.readlines()
+ except OSError:
+ print('EX: unable to read blog 4 ' + post_filename)
+
+ if lines:
+ replies_str = ''
+ for reply_post_id in lines:
+ reply_post_id = remove_eol(reply_post_id)
+ reply_post_id = reply_post_id.replace('.json', '')
+ reply_post_id = reply_post_id.replace('.replies', '')
+ post_filename = acct_dir(base_dir, nickname, domain) + \
'/postcache/' + \
- replyPostId.replace('/', '#') + '.html'
- if not os.path.isfile(postFilename):
+ reply_post_id.replace('/', '#') + '.html'
+ if not os.path.isfile(post_filename):
continue
- with open(postFilename, 'r') as postFile:
- repliesStr += postFile.read() + '\n'
- rply = _getBlogReplies(baseDir, httpPrefix, translate,
- nickname, domain, domainFull,
- replyPostId, depth+1)
- if rply not in repliesStr:
- repliesStr += rply
+ try:
+ with open(post_filename, 'r', encoding='utf-8') as post_file:
+ replies_str += post_file.read() + '\n'
+ except OSError:
+ print('EX: unable to read blog replies ' + post_filename)
+ rply = _get_blog_replies(base_dir, http_prefix, translate,
+ nickname, domain, domain_full,
+ reply_post_id, depth+1)
+ if rply not in replies_str:
+ replies_str += rply
# indicate the reply indentation level
- indentStr = '>'
- for indentLevel in range(depth):
- indentStr += ' >'
+ indent_str = '>'
+ indent_level = 0
+ while indent_level < depth:
+ indent_str += ' >'
+ indent_level += 1
- repliesStr = repliesStr.replace(translate['SHOW MORE'], indentStr)
- return repliesStr.replace('?tl=outbox', '?tl=tlblogs')
+ replies_str = replies_str.replace(translate['SHOW MORE'], indent_str)
+ return replies_str.replace('?tl=outbox', '?tl=tlblogs')
return ''
-def _htmlBlogPostContent(authorized: bool,
- baseDir: str, httpPrefix: str, translate: {},
- nickname: str, domain: str, domainFull: str,
- postJsonObject: {},
- handle: str, restrictToDomain: bool,
- peertubeInstances: [],
- systemLanguage: str,
- personCache: {},
- blogSeparator: str = '' + \ - titleStr + '
\n' - articleAdded = True + blog_str = '' + message_link = '' + if post_json_object['object'].get('id'): + message_link = \ + post_json_object['object']['id'].replace('/statuses/', '/') + title_str = '' + article_added = False + if post_json_object['object'].get('summary'): + title_str = post_json_object['object']['summary'] + blog_str += '' + \ + title_str + '
\n' + article_added = True # get the handle of the author - if postJsonObject['object'].get('attributedTo'): - authorNickname = None - if isinstance(postJsonObject['object']['attributedTo'], str): - actor = postJsonObject['object']['attributedTo'] - authorNickname = getNicknameFromActor(actor) - if authorNickname: - authorDomain, authorPort = getDomainFromActor(actor) - if authorDomain: + if post_json_object['object'].get('attributedTo'): + author_nickname = None + if isinstance(post_json_object['object']['attributedTo'], str): + actor = post_json_object['object']['attributedTo'] + author_nickname = get_nickname_from_actor(actor) + if author_nickname: + author_domain, _ = get_domain_from_actor(actor) + if author_domain: # author must be from the given domain - if restrictToDomain and authorDomain != domain: + if restrict_to_domain and author_domain != domain: return '' - handle = authorNickname + '@' + authorDomain + handle = author_nickname + '@' + author_domain else: # posts from the domain are expected to have an attributedTo field - if restrictToDomain: + if restrict_to_domain: return '' - if postJsonObject['object'].get('published'): - if 'T' in postJsonObject['object']['published']: - blogStr += '' + \
- postJsonObject['object']['published'].split('T')[0]
+ if post_json_object['object'].get('published'):
+ if 'T' in post_json_object['object']['published']:
+ blog_str += '' + \
+ post_json_object['object']['published'].split('T')[0]
if handle:
if handle.startswith(nickname + '@' + domain):
- blogStr += ' ' + handle + ''
- linkedAuthor = True
+ linked_author = True
else:
if actor:
- blogStr += ' ' + \
+ blog_str += ' ' + \
handle + ''
- linkedAuthor = True
+ linked_author = True
else:
- blogStr += ' ' + handle
- blogStr += '
\n'
+ blog_str += ' ' + handle
+ blog_str += '
\n'
- avatarLink = ''
- replyStr = ''
- announceStr = ''
- likeStr = ''
- bookmarkStr = ''
- deleteStr = ''
- muteStr = ''
- isMuted = False
- attachmentStr, galleryStr = getPostAttachmentsAsHtml(postJsonObject,
- 'tlblogs', translate,
- isMuted, avatarLink,
- replyStr, announceStr,
- likeStr, bookmarkStr,
- deleteStr, muteStr)
- if attachmentStr:
- blogStr += '' + contentStr + '
' + content_str + '
'
- dateAndLocation += \
+ date_and_location += \
''
- dateAndLocation += ''
- dateAndLocation += '
' + \
'Compelling description with #ExcitingHashtag, which is ' + \
'being posted in #BoringForum'
- tags = getNewswireTags(rssDescription, 10)
+ tags = get_newswire_tags(rss_description, 10)
assert len(tags) == 2
assert '#BoringForum' in tags
assert '#ExcitingHashtag' in tags
-def _testFirstParagraphFromString():
- print('testFirstParagraphFromString')
- testStr = \
+def _test_first_paragraph_from_string():
+ print('test_first_paragraph_from_string')
+ test_str = \
'
.'
+ result = markdown_to_html(markdown)
+ if result != expected:
+ print(result)
+ assert result == expected
-def _testExtractTextFieldsInPOST():
- print('testExtractTextFieldsInPOST')
+def _test_extract_text_fields_from_post():
+ print('test_extract_text_fields_in_post')
+ boundary = '--LYNX'
+ form_data = '--LYNX\r\nContent-Disposition: form-data; ' + \
+ 'name="fieldName"\r\nContent-Type: text/plain; ' + \
+ 'charset=utf-8\r\n\r\nThis is a lynx test\r\n' + \
+ '--LYNX\r\nContent-Disposition: ' + \
+ 'form-data; name="submitYes"\r\nContent-Type: text/plain; ' + \
+ 'charset=utf-8\r\n\r\nBUTTON\r\n--LYNX--\r\n'
+ debug = True
+ fields = extract_text_fields_in_post(None, boundary, debug, form_data)
+ print('fields: ' + str(fields))
+ assert fields
+ assert fields['fieldName'] == 'This is a lynx test'
+ assert fields['submitYes'] == 'BUTTON'
+
boundary = '-----------------------------116202748023898664511855843036'
- formData = '-----------------------------116202748023898664511855' + \
+ form_data = '-----------------------------116202748023898664511855' + \
'843036\r\nContent-Disposition: form-data; name="submitPost"' + \
'\r\n\r\nSubmit\r\n-----------------------------116202748023' + \
'898664511855843036\r\nContent-Disposition: form-data; name=' + \
@@ -4874,7 +5903,7 @@ def _testExtractTextFieldsInPOST():
'application/octet-stream\r\n\r\n\r\n----------------------' + \
'-------116202748023898664511855843036--\r\n'
debug = False
- fields = extractTextFieldsInPOST(None, boundary, debug, formData)
+ fields = extract_text_fields_in_post(None, boundary, debug, form_data)
assert fields['submitPost'] == 'Submit'
assert fields['subject'] == ''
assert fields['commentsEnabled'] == 'on'
@@ -4885,7 +5914,7 @@ def _testExtractTextFieldsInPOST():
assert fields['message'] == 'This is a ; test'
-def _testSpeakerReplaceLinks():
+def _test_speaker_replace_link():
print('testSpeakerReplaceLinks')
text = 'The Tor Project: For Snowflake volunteers: If you use ' + \
'Firefox, Brave, or Chrome, our Snowflake extension turns ' + \
@@ -4894,41 +5923,42 @@ def _testSpeakerReplaceLinks():
'not run more than one snowflake in the same ' + \
'network.https://support.torproject.org/censorship/' + \
'how-to-help-running-snowflake/'
- detectedLinks = []
- result = speakerReplaceLinks(text, {'Linked': 'Web link'}, detectedLinks)
- assert len(detectedLinks) == 1
- assert detectedLinks[0] == \
+ detected_links = []
+ result = \
+ speaker_replace_links(text, {'Linked': 'Web link'}, detected_links)
+ assert len(detected_links) == 1
+ assert detected_links[0] == \
'https://support.torproject.org/censorship/' + \
'how-to-help-running-snowflake/'
assert 'Web link support.torproject.org' in result
-def _testCamelCaseSplit():
- print('testCamelCaseSplit')
- testStr = 'ThisIsCamelCase'
- assert camelCaseSplit(testStr) == 'This Is Camel Case'
+def _test_camel_case_split():
+ print('test_camel_case_split')
+ test_str = 'ThisIsCamelCase'
+ assert camel_case_split(test_str) == 'This Is Camel Case'
- testStr = 'Notcamelcase test'
- assert camelCaseSplit(testStr) == 'Notcamelcase test'
+ test_str = 'Notcamelcase test'
+ assert camel_case_split(test_str) == 'Notcamelcase test'
-def _testEmojiImages():
- print('testEmojiImages')
- emojiFilename = 'emoji/default_emoji.json'
- assert os.path.isfile(emojiFilename)
- emojiJson = loadJson(emojiFilename)
- assert emojiJson
- for emojiName, emojiImage in emojiJson.items():
- emojiImageFilename = 'emoji/' + emojiImage + '.png'
- if not os.path.isfile(emojiImageFilename):
- print('Missing emoji image ' + emojiName + ' ' +
- emojiImage + '.png')
- assert os.path.isfile(emojiImageFilename)
+def _test_emoji_images():
+ print('test_emoji_images')
+ emoji_filename = 'emoji/default_emoji.json'
+ assert os.path.isfile(emoji_filename)
+ emoji_json = load_json(emoji_filename)
+ assert emoji_json
+ for emoji_name, emoji_image in emoji_json.items():
+ emoji_image_filename = 'emoji/' + emoji_image + '.png'
+ if not os.path.isfile(emoji_image_filename):
+ print('Missing emoji image ' + emoji_name + ' ' +
+ emoji_image + '.png')
+ assert os.path.isfile(emoji_image_filename)
-def _testExtractPGPPublicKey():
+def _test_extract_pgp_public_key():
print('testExtractPGPPublicKey')
- pubKey = \
+ pub_key = \
'-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n' + \
'mDMEWZBueBYJKwYBBAHaRw8BAQdAKx1t6wL0RTuU6/' + \
'IBjngMbVJJ3Wg/3UW73/PV\n' + \
@@ -4949,74 +5979,77 @@ def _testExtractPGPPublicKey():
'fnaZ2Wi050483Sj2RmQRpb99Dod7rVZTDtCqXk0J\n' + \
'=gv5G\n' + \
'-----END PGP PUBLIC KEY BLOCK-----'
- testStr = "Some introduction\n\n" + pubKey + "\n\nSome message."
- assert containsPGPPublicKey(testStr)
- assert not containsPGPPublicKey('String without a pgp key')
- result = extractPGPPublicKey(testStr)
+ test_str = "Some introduction\n\n" + pub_key + "\n\nSome message."
+ assert contains_pgp_public_key(test_str)
+ assert not contains_pgp_public_key('String without a pgp key')
+ result = extract_pgp_public_key(test_str)
assert result
- assert result == pubKey
+ assert result == pub_key
-def testUpdateActor(baseDir: str):
+def test_update_actor(base_dir: str):
print('Testing update of actor properties')
- global testServerAliceRunning
- testServerAliceRunning = False
+ global TEST_SERVER_ALICE_RUNNING
+ TEST_SERVER_ALICE_RUNNING = False
- httpPrefix = 'http'
- proxyType = None
- federationList = []
+ http_prefix = 'http'
+ proxy_type = None
+ federation_list = []
- if os.path.isdir(baseDir + '/.tests'):
- shutil.rmtree(baseDir + '/.tests')
- os.mkdir(baseDir + '/.tests')
+ if os.path.isdir(base_dir + '/.tests'):
+ shutil.rmtree(base_dir + '/.tests',
+ ignore_errors=False, onerror=None)
+ os.mkdir(base_dir + '/.tests')
# create the server
- aliceDir = baseDir + '/.tests/alice'
- aliceDomain = '127.0.0.11'
- alicePort = 61792
- aliceSendThreads = []
- bobAddress = '127.0.0.84:6384'
+ alice_dir = base_dir + '/.tests/alice'
+ alice_domain = '127.0.0.11'
+ alice_port = 61792
+ alice_send_threads = []
+ bob_address = '127.0.0.84:6384'
- global thrAlice
- if thrAlice:
- while thrAlice.is_alive():
- thrAlice.stop()
+ global THR_ALICE
+ if THR_ALICE:
+ while THR_ALICE.is_alive():
+ THR_ALICE.stop()
time.sleep(1)
- thrAlice.kill()
+ THR_ALICE.kill()
- thrAlice = \
- threadWithTrace(target=createServerAlice,
- args=(aliceDir, aliceDomain, alicePort, bobAddress,
- federationList, False, False,
- aliceSendThreads),
- daemon=True)
+ THR_ALICE = \
+ thread_with_trace(target=create_server_alice,
+ args=(alice_dir, alice_domain,
+ alice_port, bob_address,
+ federation_list, False, False,
+ alice_send_threads),
+ daemon=True)
- thrAlice.start()
- assert thrAlice.is_alive() is True
+ THR_ALICE.start()
+ assert THR_ALICE.is_alive() is True
# wait for server to be running
ctr = 0
- while not testServerAliceRunning:
+ while not TEST_SERVER_ALICE_RUNNING:
time.sleep(1)
ctr += 1
if ctr > 60:
break
- print('Alice online: ' + str(testServerAliceRunning))
+ print('Alice online: ' + str(TEST_SERVER_ALICE_RUNNING))
print('\n\n*******************************************************')
print('Alice updates her PGP key')
- sessionAlice = createSession(proxyType)
- cachedWebfingers = {}
- personCache = {}
+ session_alice = create_session(proxy_type)
+ cached_webfingers = {}
+ person_cache = {}
password = 'alicepass'
- outboxPath = aliceDir + '/accounts/alice@' + aliceDomain + '/outbox'
- actorFilename = aliceDir + '/accounts/' + 'alice@' + aliceDomain + '.json'
- assert os.path.isfile(actorFilename)
- assert len([name for name in os.listdir(outboxPath)
- if os.path.isfile(os.path.join(outboxPath, name))]) == 0
- pubKey = \
+ outbox_path = alice_dir + '/accounts/alice@' + alice_domain + '/outbox'
+ actor_filename = \
+ alice_dir + '/accounts/' + 'alice@' + alice_domain + '.json'
+ assert os.path.isfile(actor_filename)
+ assert len([name for name in os.listdir(outbox_path)
+ if os.path.isfile(os.path.join(outbox_path, name))]) == 0
+ pub_key = \
'-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n' + \
'mDMEWZBueBYJKwYBBAHaRw8BAQdAKx1t6wL0RTuU6/' + \
'IBjngMbVJJ3Wg/3UW73/PV\n' + \
@@ -5037,45 +6070,45 @@ def testUpdateActor(baseDir: str):
'fnaZ2Wi050483Sj2RmQRpb99Dod7rVZTDtCqXk0J\n' + \
'=gv5G\n' + \
'-----END PGP PUBLIC KEY BLOCK-----'
- signingPrivateKeyPem = None
- actorUpdate = \
- pgpPublicKeyUpload(aliceDir, sessionAlice,
- 'alice', password,
- aliceDomain, alicePort,
- httpPrefix,
- cachedWebfingers, personCache,
- True, pubKey, signingPrivateKeyPem)
- print('actor update result: ' + str(actorUpdate))
- assert actorUpdate
+ signing_priv_key_pem = None
+ actor_update = \
+ pgp_public_key_upload(alice_dir, session_alice,
+ 'alice', password,
+ alice_domain, alice_port,
+ http_prefix,
+ cached_webfingers, person_cache,
+ True, pub_key, signing_priv_key_pem)
+ print('actor update result: ' + str(actor_update))
+ assert actor_update
# load alice actor
- print('Loading actor: ' + actorFilename)
- actorJson = loadJson(actorFilename)
- assert actorJson
- if len(actorJson['attachment']) == 0:
- print("actorJson['attachment'] has no contents")
- assert len(actorJson['attachment']) > 0
- propertyFound = False
- for propertyValue in actorJson['attachment']:
- if propertyValue['name'] == 'PGP':
+ print('Loading actor: ' + actor_filename)
+ actor_json = load_json(actor_filename)
+ assert actor_json
+ if len(actor_json['attachment']) == 0:
+ print("actor_json['attachment'] has no contents")
+ assert len(actor_json['attachment']) > 0
+ property_found = False
+ for property_value in actor_json['attachment']:
+ if property_value['name'] == 'PGP':
print('PGP property set within attachment')
- assert pubKey in propertyValue['value']
- propertyFound = True
- assert propertyFound
+ assert pub_key in property_value['value']
+ property_found = True
+ assert property_found
# stop the server
- thrAlice.kill()
- thrAlice.join()
- assert thrAlice.is_alive() is False
+ THR_ALICE.kill()
+ THR_ALICE.join()
+ assert THR_ALICE.is_alive() is False
- os.chdir(baseDir)
- if os.path.isdir(baseDir + '/.tests'):
- shutil.rmtree(baseDir + '/.tests')
+ os.chdir(base_dir)
+ if os.path.isdir(base_dir + '/.tests'):
+ shutil.rmtree(base_dir + '/.tests', ignore_errors=False, onerror=None)
-def _testRemovePostInteractions() -> None:
- print('testRemovePostInteractions')
- postJsonObject = {
+def _test_remove_interactions() -> None:
+ print('test_remove_post_interactions')
+ post_json_object = {
"type": "Create",
"object": {
"to": ["#Public"],
@@ -5096,19 +6129,19 @@ def _testRemovePostInteractions() -> None:
}
}
}
- removePostInteractions(postJsonObject, True)
- assert postJsonObject['object']['likes']['items'] == []
- assert postJsonObject['object']['replies'] == {}
- assert postJsonObject['object']['shares'] == {}
- assert postJsonObject['object']['bookmarks'] == {}
- assert postJsonObject['object']['ignores'] == {}
- postJsonObject['object']['to'] = ["some private address"]
- assert not removePostInteractions(postJsonObject, False)
+ remove_post_interactions(post_json_object, True)
+ assert post_json_object['object']['likes']['items'] == []
+ assert post_json_object['object']['replies'] == {}
+ assert post_json_object['object']['shares'] == {}
+ assert post_json_object['object']['bookmarks'] == {}
+ assert post_json_object['object']['ignores'] == {}
+ post_json_object['object']['to'] = ["some private address"]
+ assert not remove_post_interactions(post_json_object, False)
-def _testSpoofGeolocation() -> None:
- print('testSpoofGeolocation')
- nogoLine = \
+def _test_spoofed_geolocation() -> None:
+ print('test_spoof_geolocation')
+ nogo_line = \
'NEW YORK, USA: 73.951W,40.879, 73.974W,40.83, ' + \
'74.029W,40.756, 74.038W,40.713, 74.056W,40.713, ' + \
'74.127W,40.647, 74.038W,40.629, 73.995W,40.667, ' + \
@@ -5117,11 +6150,11 @@ def _testSpoofGeolocation() -> None:
'73.937W,40.793, 73.946W,40.782, 73.977W,40.738, ' + \
'73.98W,40.713, 74.012W,40.705, 74.006W,40.752, ' + \
'73.955W,40.824'
- polygon = parseNogoString(nogoLine)
+ polygon = parse_nogo_string(nogo_line)
assert len(polygon) > 0
assert polygon[0][1] == -73.951
assert polygon[0][0] == 40.879
- citiesList = [
+ cities_list = [
'NEW YORK, USA:40.7127281:W74.0060152:784',
'LOS ANGELES, USA:34.0536909:W118.242766:1214',
'SAN FRANCISCO, USA:37.74594738515095:W122.44299445520019:121',
@@ -5132,114 +6165,114 @@ def _testSpoofGeolocation() -> None:
'LONDON, ENGLAND:51.5073219:W0.1276474:1738',
'SEATTLE, USA:47.59840153253106:W122.31143714060059:217'
]
- testSquare = [
+ test_square = [
[[0.03, 0.01], [0.02, 10], [10.01, 10.02], [10.03, 0.02]]
]
- assert pointInNogo(testSquare, 5, 5)
- assert pointInNogo(testSquare, 2, 3)
- assert not pointInNogo(testSquare, 20, 5)
- assert not pointInNogo(testSquare, 11, 6)
- assert not pointInNogo(testSquare, 5, -5)
- assert not pointInNogo(testSquare, 5, 11)
- assert not pointInNogo(testSquare, -5, -5)
- assert not pointInNogo(testSquare, -5, 5)
- nogoList = []
- currTime = datetime.datetime.utcnow()
- decoySeed = 7634681
- cityRadius = 0.1
- coords = spoofGeolocation('', 'los angeles', currTime,
- decoySeed, citiesList, nogoList)
- assert coords[0] >= 34.0536909 - cityRadius
- assert coords[0] <= 34.0536909 + cityRadius
- assert coords[1] >= 118.242766 - cityRadius
- assert coords[1] <= 118.242766 + cityRadius
+ assert point_in_nogo(test_square, 5, 5)
+ assert point_in_nogo(test_square, 2, 3)
+ assert not point_in_nogo(test_square, 20, 5)
+ assert not point_in_nogo(test_square, 11, 6)
+ assert not point_in_nogo(test_square, 5, -5)
+ assert not point_in_nogo(test_square, 5, 11)
+ assert not point_in_nogo(test_square, -5, -5)
+ assert not point_in_nogo(test_square, -5, 5)
+ nogo_list = []
+ curr_time = datetime.datetime.utcnow()
+ decoy_seed = 7634681
+ city_radius = 0.1
+ coords = spoof_geolocation('', 'los angeles', curr_time,
+ decoy_seed, cities_list, nogo_list)
+ assert coords[0] >= 34.0536909 - city_radius
+ assert coords[0] <= 34.0536909 + city_radius
+ assert coords[1] >= 118.242766 - city_radius
+ assert coords[1] <= 118.242766 + city_radius
assert coords[2] == 'N'
assert coords[3] == 'W'
assert len(coords[4]) > 4
assert len(coords[5]) > 4
assert coords[6] > 0
- nogoList = []
- coords = spoofGeolocation('', 'unknown', currTime,
- decoySeed, citiesList, nogoList)
- assert coords[0] >= 51.8744 - cityRadius
- assert coords[0] <= 51.8744 + cityRadius
- assert coords[1] >= 0.368333 - cityRadius
- assert coords[1] <= 0.368333 + cityRadius
+ nogo_list = []
+ coords = spoof_geolocation('', 'unknown', curr_time,
+ decoy_seed, cities_list, nogo_list)
+ assert coords[0] >= 51.8744 - city_radius
+ assert coords[0] <= 51.8744 + city_radius
+ assert coords[1] >= 0.368333 - city_radius
+ assert coords[1] <= 0.368333 + city_radius
assert coords[2] == 'N'
assert coords[3] == 'W'
assert len(coords[4]) == 0
assert len(coords[5]) == 0
assert coords[6] == 0
- kmlStr = '\n'
- kmlStr += '![' + \
translate['Delete this event'] + ' |](/' + \
'icons/delete.png "' + \
translate['Delete this event'] + '")
![' + \
translate['Edit Links'] + ' |](/icons/edit.png "' + \
translate['Edit Links'] + '"){kind=icon}
![' + \
+ translate['Theme Designer'] + ' |](/icons/theme.png "' + \
+ translate['Theme Designer'] + '"){kind=icon}
![' + \
+ rss_title + '](/icons/logorss.png "' + rss_title + \
'"){kind=icon}
![| ' + translate['Create a new DM'] + \
'](/' + \
'icons/newpost.png "' + \
translate['Create a new DM'] + \
'")
![| ' + \
translate['Create a new post'] + \
'](/' + \
'icons/newpost.png "' + \
translate['Create a new post'] + '")
![' + \
translate['Approve follow requests'] + \
'](/icons/person.png "' + translate['Approve follow requests'] + \
'"){kind=icon}