Mute and unmute via c2s

blocking.py

@@ -7,7 +7,10 @@ __email__ = "bob@freedombone.net"
 __status__ = "Production"
 
 import os
+import json
 from datetime import datetime
+from utils import getCachedPostFilename
+from utils import loadJson
 from utils import fileLastModified
 from utils import setConfigParam
 from utils import hasUsersPath
@@ -361,6 +364,203 @@ def outboxUndoBlock(baseDir: str, httpPrefix: str,
         print('DEBUG: post undo blocked via c2s - ' + postFilename)
 
 
+def mutePost(baseDir: str, nickname: str, domain: str, postId: str,
+             recentPostsCache: {}) -> None:
+    """ Mutes the given post
+    """
+    postFilename = locatePost(baseDir, nickname, domain, postId)
+    if not postFilename:
+        return
+    postJsonObject = loadJson(postFilename)
+    if not postJsonObject:
+        return
+
+    # 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):
+            os.remove(cachedPostFilename)
+
+    muteFile = open(postFilename + '.muted', 'w+')
+    if muteFile:
+        muteFile.write('\n')
+        muteFile.close()
+        print('MUTE: ' + postFilename + '.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['json'].get(postId):
+                postJsonObject['muted'] = True
+                recentPostsCache['json'][postId] = json.dumps(postJsonObject)
+                if recentPostsCache.get('html'):
+                    if recentPostsCache['html'].get(postId):
+                        del recentPostsCache['html'][postId]
+                print('MUTE: ' + postId +
+                      ' marked as muted in recent posts memory cache')
+
+
+def unmutePost(baseDir: str, nickname: str, domain: str, postId: str,
+               recentPostsCache: {}) -> None:
+    """ Unmutes the given post
+    """
+    postFilename = locatePost(baseDir, nickname, domain, postId)
+    if not postFilename:
+        return
+    postJsonObject = loadJson(postFilename)
+    if not postJsonObject:
+        return
+
+    muteFilename = postFilename + '.muted'
+    if os.path.isfile(muteFilename):
+        os.remove(muteFilename)
+        print('UNMUTE: ' + muteFilename + ' file removed')
+
+    # 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):
+            os.remove(cachedPostFilename)
+
+    # 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['json'].get(postId):
+                postJsonObject['muted'] = False
+                recentPostsCache['json'][postId] = json.dumps(postJsonObject)
+                if recentPostsCache.get('html'):
+                    if recentPostsCache['html'].get(postId):
+                        del recentPostsCache['html'][postId]
+                print('UNMUTE: ' + postId +
+                      ' marked as unmuted in recent posts cache')
+
+
+def outboxMute(baseDir: str, httpPrefix: str,
+               nickname: str, domain: str, port: int,
+               messageJson: {}, debug: bool,
+               recentPostsCache: {}) -> None:
+    """When a mute is received by the outbox from c2s
+    """
+    if not messageJson.get('type'):
+        return
+    if not messageJson.get('actor'):
+        return
+    domainFull = getFullDomain(domain, port)
+    if not messageJson['actor'].endswith(domainFull + '/users/' + nickname):
+        return
+    if not messageJson['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')
+        return
+    if debug:
+        print('DEBUG: c2s mute request arrived in outbox')
+
+    messageId = removeIdEnding(messageJson['object'])
+    if '/statuses/' not in messageId:
+        if debug:
+            print('DEBUG: c2s mute object is not a status')
+        return
+    if not hasUsersPath(messageId):
+        if debug:
+            print('DEBUG: c2s mute object has no nickname')
+        return
+    if ':' in domain:
+        domain = domain.split(':')[0]
+    postFilename = locatePost(baseDir, nickname, domain, messageId)
+    if not postFilename:
+        if debug:
+            print('DEBUG: c2s mute post not found in inbox or outbox')
+            print(messageId)
+        return
+    nicknameMuted = getNicknameFromActor(messageJson['object'])
+    if not nicknameMuted:
+        print('WARN: unable to find nickname in ' + messageJson['object'])
+        return
+
+    mutePost(baseDir, nickname, domain,
+             messageJson['object'], recentPostsCache)
+
+    if debug:
+        print('DEBUG: post muted via c2s - ' + postFilename)
+
+
+def outboxUndoMute(baseDir: str, httpPrefix: str,
+                   nickname: str, domain: str, port: int,
+                   messageJson: {}, debug: bool,
+                   recentPostsCache: {}) -> None:
+    """When an undo mute is received by the outbox from c2s
+    """
+    if not messageJson.get('type'):
+        return
+    if not messageJson.get('actor'):
+        return
+    domainFull = getFullDomain(domain, port)
+    if not messageJson['actor'].endswith(domainFull + '/users/' + nickname):
+        return
+    if not messageJson['type'] == 'Undo':
+        return
+    if not messageJson.get('object'):
+        return
+    if not isinstance(messageJson['object'], dict):
+        return
+    if not messageJson['object'].get('type'):
+        return
+    if messageJson['object']['type'] != 'Ignore':
+        return
+    if not isinstance(messageJson['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:
+        if debug:
+            print('DEBUG: c2s undo mute object is not a status')
+        return
+    if not hasUsersPath(messageId):
+        if debug:
+            print('DEBUG: c2s undo mute object has no nickname')
+        return
+    if ':' in domain:
+        domain = domain.split(':')[0]
+    postFilename = locatePost(baseDir, nickname, domain, messageId)
+    if not postFilename:
+        if debug:
+            print('DEBUG: c2s undo mute post not found in inbox or outbox')
+            print(messageId)
+        return
+    nicknameMuted = getNicknameFromActor(messageJson['object']['object'])
+    if not nicknameMuted:
+        print('WARN: unable to find nickname in ' +
+              messageJson['object']['object'])
+        return
+
+    unmutePost(baseDir, nickname, domain,
+               messageJson['object']['object'],
+               recentPostsCache)
+
+    if debug:
+        print('DEBUG: post undo mute via c2s - ' + postFilename)
+
+
 def setBrochMode(baseDir: str, domainFull: 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.

daemon.py

@@ -73,8 +73,6 @@ from posts import pinPost
 from posts import jsonPinPost
 from posts import undoPinnedPost
 from posts import isModerator
-from posts import mutePost
-from posts import unmutePost
 from posts import createQuestionPost
 from posts import createPublicPost
 from posts import createBlogPost
@@ -108,6 +106,8 @@ from threads import threadWithTrace
 from threads import removeDormantThreads
 from media import replaceYouTube
 from media import attachMedia
+from blocking import mutePost
+from blocking import unmutePost
 from blocking import setBrochMode
 from blocking import addBlock
 from blocking import removeBlock

epicyon.py

@@ -24,6 +24,8 @@ from roles import setRole
 from webfinger import webfingerHandle
 from bookmarks import sendBookmarkViaServer
 from bookmarks import sendUndoBookmarkViaServer
+from posts import sendMuteViaServer
+from posts import sendUndoMuteViaServer
 from posts import c2sBoxJson
 from posts import downloadFollowCollection
 from posts import getPublicPostDomains
@@ -478,6 +480,10 @@ parser.add_argument('--block', dest='block', type=str, default=None,
                     help='Block a particular address')
 parser.add_argument('--unblock', dest='unblock', type=str, default=None,
                     help='Remove a block on a particular address')
+parser.add_argument('--mute', dest='mute', type=str, default=None,
+                    help='Mute a particular post URL')
+parser.add_argument('--unmute', dest='unmute', type=str, default=None,
+                    help='Unmute a particular post URL')
 parser.add_argument('--delegate', dest='delegate', type=str, default=None,
                     help='Address of an account to delegate a role to')
 parser.add_argument('--undodelegate', '--undelegate', dest='undelegate',
@@ -2036,6 +2042,60 @@ if args.block:
         time.sleep(1)
     sys.exit()
 
+if args.mute:
+    if not nickname:
+        print('Specify a nickname with the --nickname option')
+        sys.exit()
+
+    if not args.password:
+        args.password = getpass.getpass('Password: ')
+        if not args.password:
+            print('Specify a password with the --password option')
+            sys.exit()
+    args.password = args.password.replace('\n', '')
+
+    session = createSession(proxyType)
+    personCache = {}
+    cachedWebfingers = {}
+    print('Sending mute of ' + args.mute)
+
+    sendMuteViaServer(baseDir, session, nickname, args.password,
+                      domain, port,
+                      httpPrefix, args.mute,
+                      cachedWebfingers, personCache,
+                      True, __version__)
+    for i in range(10):
+        # TODO detect send success/fail
+        time.sleep(1)
+    sys.exit()
+
+if args.unmute:
+    if not nickname:
+        print('Specify a nickname with the --nickname option')
+        sys.exit()
+
+    if not args.password:
+        args.password = getpass.getpass('Password: ')
+        if not args.password:
+            print('Specify a password with the --password option')
+            sys.exit()
+    args.password = args.password.replace('\n', '')
+
+    session = createSession(proxyType)
+    personCache = {}
+    cachedWebfingers = {}
+    print('Sending undo mute of ' + args.unmute)
+
+    sendUndoMuteViaServer(baseDir, session, nickname, args.password,
+                          domain, port,
+                          httpPrefix, args.unmute,
+                          cachedWebfingers, personCache,
+                          True, __version__)
+    for i in range(10):
+        # TODO detect send success/fail
+        time.sleep(1)
+    sys.exit()
+
 if args.delegate:
     if not nickname:
         print('Specify a nickname with the --nickname option')

outbox.py

@@ -26,6 +26,8 @@ from utils import saveJson
 from blocking import isBlockedDomain
 from blocking import outboxBlock
 from blocking import outboxUndoBlock
+from blocking import outboxMute
+from blocking import outboxUndoMute
 from media import replaceYouTube
 from media import getMediaPath
 from media import createMediaDirs
@@ -515,6 +517,22 @@ def postMessageToOutbox(session, translate: {},
                     postToNickname, domain,
                     port, messageJson, debug)
 
+    if debug:
+        print('DEBUG: handle mute requests')
+    outboxMute(baseDir, httpPrefix,
+               postToNickname, domain,
+               port,
+               messageJson, debug,
+               recentPostsCache)
+
+    if debug:
+        print('DEBUG: handle undo mute requests')
+    outboxUndoMute(baseDir, httpPrefix,
+                   postToNickname, domain,
+                   port,
+                   messageJson, debug,
+                   recentPostsCache)
+
     if debug:
         print('DEBUG: handle share uploads')
     outboxShareUpload(baseDir, httpPrefix,

posts.py

@@ -40,8 +40,6 @@ from utils import validPostDate
 from utils import getFullDomain
 from utils import getFollowersList
 from utils import isEvil
-from utils import removeIdEnding
-from utils import getCachedPostFilename
 from utils import getStatusNumber
 from utils import createPersonDir
 from utils import urlPermitted
@@ -1827,17 +1825,6 @@ def createReportPost(baseDir: str,
         if not postJsonObject:
             continue
 
-        # update the inbox index with the report filename
-        # indexFilename = baseDir+'/accounts/'+handle+'/inbox.index'
-        # indexEntry = \
-        #     removeIdEnding(postJsonObject['id']).replace('/','#') + '.json'
-        # if indexEntry not in open(indexFilename).read():
-        #     try:
-        #         with open(indexFilename, 'a+') as fp:
-        #             fp.write(indexEntry)
-        #     except:
-        #         pass
-
         # save a notification file so that the moderator
         # knows something new has appeared
         newReportFile = baseDir + '/accounts/' + handle + '/.newReport'
@@ -4065,87 +4052,6 @@ def isMuted(baseDir: str, nickname: str, domain: str, postId: str) -> bool:
     return False
 
 
-def mutePost(baseDir: str, nickname: str, domain: str, postId: str,
-             recentPostsCache: {}) -> None:
-    """ Mutes the given post
-    """
-    postFilename = locatePost(baseDir, nickname, domain, postId)
-    if not postFilename:
-        return
-    postJsonObject = loadJson(postFilename)
-    if not postJsonObject:
-        return
-
-    # 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):
-            os.remove(cachedPostFilename)
-
-    muteFile = open(postFilename + '.muted', 'w+')
-    if muteFile:
-        muteFile.write('\n')
-        muteFile.close()
-        print('MUTE: ' + postFilename + '.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['json'].get(postId):
-                postJsonObject['muted'] = True
-                recentPostsCache['json'][postId] = json.dumps(postJsonObject)
-                if recentPostsCache.get('html'):
-                    if recentPostsCache['html'].get(postId):
-                        del recentPostsCache['html'][postId]
-                print('MUTE: ' + postId +
-                      ' marked as muted in recent posts memory cache')
-
-
-def unmutePost(baseDir: str, nickname: str, domain: str, postId: str,
-               recentPostsCache: {}) -> None:
-    """ Unmutes the given post
-    """
-    postFilename = locatePost(baseDir, nickname, domain, postId)
-    if not postFilename:
-        return
-    postJsonObject = loadJson(postFilename)
-    if not postJsonObject:
-        return
-
-    muteFilename = postFilename + '.muted'
-    if os.path.isfile(muteFilename):
-        os.remove(muteFilename)
-        print('UNMUTE: ' + muteFilename + ' file removed')
-
-    # 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):
-            os.remove(cachedPostFilename)
-
-    # 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['json'].get(postId):
-                postJsonObject['muted'] = False
-                recentPostsCache['json'][postId] = json.dumps(postJsonObject)
-                if recentPostsCache.get('html'):
-                    if recentPostsCache['html'].get(postId):
-                        del recentPostsCache['html'][postId]
-                print('UNMUTE: ' + postId +
-                      ' marked as unmuted in recent posts cache')
-
-
 def sendBlockViaServer(baseDir: str, session,
                        fromNickname: str, password: str,
                        fromDomain: str, fromPort: int,
@@ -4226,6 +4132,159 @@ def sendBlockViaServer(baseDir: str, session,
     return newBlockJson
 
 
+def sendMuteViaServer(baseDir: str, session,
+                      fromNickname: str, password: str,
+                      fromDomain: str, fromPort: int,
+                      httpPrefix: str, mutedUrl: str,
+                      cachedWebfingers: {}, personCache: {},
+                      debug: bool, projectVersion: str) -> {}:
+    """Creates a mute via c2s
+    """
+    if not session:
+        print('WARN: No session for sendMuteViaServer')
+        return 6
+
+    fromDomainFull = getFullDomain(fromDomain, fromPort)
+
+    actor = httpPrefix + '://' + fromDomainFull + '/users/' + fromNickname
+    handle = actor.replace('/users/', '/@')
+
+    newMuteJson = {
+        "@context": "https://www.w3.org/ns/activitystreams",
+        'type': 'Ignore',
+        'actor': actor,
+        'object': mutedUrl
+    }
+
+    # lookup the inbox for the To handle
+    wfRequest = webfingerHandle(session, handle, httpPrefix,
+                                cachedWebfingers,
+                                fromDomain, projectVersion, debug)
+    if not wfRequest:
+        if debug:
+            print('DEBUG: mute webfinger failed for ' + handle)
+        return 1
+    if not isinstance(wfRequest, dict):
+        print('WARN: mute Webfinger for ' + handle +
+              ' did not return a dict. ' + str(wfRequest))
+        return 1
+
+    postToBox = 'outbox'
+
+    # get the actor inbox for the To handle
+    (inboxUrl, pubKeyId, pubKey,
+     fromPersonId, sharedInbox, avatarUrl,
+     displayName) = getPersonBox(baseDir, session, wfRequest,
+                                 personCache,
+                                 projectVersion, httpPrefix, fromNickname,
+                                 fromDomain, postToBox, 72652)
+
+    if not inboxUrl:
+        if debug:
+            print('DEBUG: mute no ' + postToBox + ' was found for ' + handle)
+        return 3
+    if not fromPersonId:
+        if debug:
+            print('DEBUG: mute no actor was found for ' + handle)
+        return 4
+
+    authHeader = createBasicAuthHeader(fromNickname, password)
+
+    headers = {
+        'host': fromDomain,
+        'Content-type': 'application/json',
+        'Authorization': authHeader
+    }
+    postResult = postJson(session, newMuteJson, [], inboxUrl,
+                          headers, 30, True)
+    if not postResult:
+        print('WARN: mute unable to post')
+
+    if debug:
+        print('DEBUG: c2s POST mute success')
+
+    return newMuteJson
+
+
+def sendUndoMuteViaServer(baseDir: str, session,
+                          fromNickname: str, password: str,
+                          fromDomain: str, fromPort: int,
+                          httpPrefix: str, mutedUrl: str,
+                          cachedWebfingers: {}, personCache: {},
+                          debug: bool, projectVersion: str) -> {}:
+    """Undoes a mute via c2s
+    """
+    if not session:
+        print('WARN: No session for sendUndoMuteViaServer')
+        return 6
+
+    fromDomainFull = getFullDomain(fromDomain, fromPort)
+
+    actor = httpPrefix + '://' + fromDomainFull + '/users/' + fromNickname
+    handle = actor.replace('/users/', '/@')
+
+    undoMuteJson = {
+        "@context": "https://www.w3.org/ns/activitystreams",
+        'type': 'Undo',
+        'actor': actor,
+        'object': {
+            'type': 'Ignore',
+            'actor': actor,
+            'object': mutedUrl
+        }
+    }
+
+    # lookup the inbox for the To handle
+    wfRequest = webfingerHandle(session, handle, httpPrefix,
+                                cachedWebfingers,
+                                fromDomain, projectVersion, debug)
+    if not wfRequest:
+        if debug:
+            print('DEBUG: undo mute webfinger failed for ' + handle)
+        return 1
+    if not isinstance(wfRequest, dict):
+        print('WARN: undo mute Webfinger for ' + handle +
+              ' did not return a dict. ' + str(wfRequest))
+        return 1
+
+    postToBox = 'outbox'
+
+    # get the actor inbox for the To handle
+    (inboxUrl, pubKeyId, pubKey,
+     fromPersonId, sharedInbox, avatarUrl,
+     displayName) = getPersonBox(baseDir, session, wfRequest,
+                                 personCache,
+                                 projectVersion, httpPrefix, fromNickname,
+                                 fromDomain, postToBox, 72652)
+
+    if not inboxUrl:
+        if debug:
+            print('DEBUG: undo mute no ' + postToBox +
+                  ' was found for ' + handle)
+        return 3
+    if not fromPersonId:
+        if debug:
+            print('DEBUG: undo mute no actor was found for ' + handle)
+        return 4
+
+    authHeader = createBasicAuthHeader(fromNickname, password)
+
+    headers = {
+        'host': fromDomain,
+        'Content-type': 'application/json',
+        'Authorization': authHeader
+    }
+    postResult = postJson(session, undoMuteJson, [], inboxUrl,
+                          headers, 30, True)
+    if not postResult:
+        print('WARN: undo mute unable to post')
+
+    if debug:
+        print('DEBUG: c2s POST undo mute success')
+
+    return undoMuteJson
+
+
 def sendUndoBlockViaServer(baseDir: str, session,
                            fromNickname: str, password: str,
                            fromDomain: str, fromPort: int,