Version 0.2.0

pappyproxy/plugins/filter.py

@@ -0,0 +1,192 @@
+import crochet
+import pappyproxy
+
+from pappyproxy.console import confirm
+from pappyproxy.util import PappyException
+from twisted.internet import defer
+
+class BuiltinFilters(object):
+    _filters = {
+        'not_image': (
+            ['path nctr "(\.png$|\.jpg$|\.gif$)"'],
+            'Filter out image requests',
+        ),
+        'not_jscss': (
+            ['path nctr "(\.js$|\.css$)"'],
+            'Filter out javascript and css files',
+        ),
+    }
+    
+    @staticmethod
+    @defer.inlineCallbacks
+    def get(name):
+        if name not in BuiltinFilters._filters:
+            raise PappyException('%s not a bult in filter' % name)
+        if name in BuiltinFilters._filters:
+            filters = [pappyproxy.context.Filter(f) for f in BuiltinFilters._filters[name][0]]
+            for f in filters:
+                yield f.generate()
+            defer.returnValue(filters)
+        raise PappyException('"%s" is not a built-in filter' % name)
+
+    @staticmethod
+    def list():
+        return [k for k, v in BuiltinFilters._filters.iteritems()]
+
+    @staticmethod
+    def help(name):
+        if name not in BuiltinFilters._filters:
+            raise PappyException('"%s" is not a built-in filter' % name)
+        return pappyproxy.context.Filter(BuiltinFilters._filters[name][1])
+
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def filtercmd(line):
+    """
+    Apply a filter to the current context
+    Usage: filter <filter string>
+    See README.md for information on filter strings
+    """
+    if not line:
+        raise PappyException("Filter string required")
+    
+    filter_to_add = pappyproxy.context.Filter(line)
+    yield filter_to_add.generate()
+    pappyproxy.pappy.main_context.add_filter(filter_to_add)
+
+def complete_builtin_filter(text, line, begidx, endidx):
+    all_names = BuiltinFilters.list()
+    if not text:
+        ret = all_names[:]
+    else:
+        ret = [n for n in all_names if n.startswith(text)]
+    return ret
+    
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def builtin_filter(line):
+    if not line:
+        raise PappyException("Filter name required")
+    
+    filters_to_add = yield BuiltinFilters.get(line)
+    for f in filters_to_add:
+        print f.filter_string
+        pappyproxy.pappy.main_context.add_filter(f)
+    defer.returnValue(None)
+
+def filter_up(line):
+    """
+    Remove the last applied filter
+    Usage: filter_up
+    """
+    pappyproxy.pappy.main_context.filter_up()
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def filter_clear(line):
+    """
+    Reset the context so that it contains no filters (ignores scope)
+    Usage: filter_clear
+    """
+    pappyproxy.pappy.main_context.active_filters = []
+    yield pappyproxy.context.reload_from_storage()
+
+def filter_list(line):
+    """
+    Print the filters that make up the current context
+    Usage: filter_list
+    """
+    for f in pappyproxy.pappy.main_context.active_filters:
+        print f.filter_string
+
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def scope_save(line):
+    """
+    Set the scope to be the current context. Saved between launches
+    Usage: scope_save
+    """
+    pappyproxy.context.save_scope(pappyproxy.pappy.main_context)
+    yield pappyproxy.context.store_scope(pappyproxy.http.dbpool)
+
+def scope_reset(line):
+    """
+    Set the context to be the scope (view in-scope items)
+    Usage: scope_reset
+    """
+    pappyproxy.context.reset_to_scope(pappyproxy.pappy.main_context)
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def scope_delete(line):
+    """
+    Delete the scope so that it contains all request/response pairs
+    Usage: scope_delete
+    """
+    pappyproxy.context.set_scope([])
+    yield pappyproxy.context.store_scope(pappyproxy.http.dbpool)
+
+def scope_list(line):
+    """
+    Print the filters that make up the scope
+    Usage: scope_list
+    """
+    pappyproxy.context.print_scope()
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def filter_prune(line):
+    """
+    Delete all out of context requests from the data file. 
+    CANNOT BE UNDONE!! Be careful!
+    Usage: filter_prune
+    """
+    # Delete filtered items from datafile
+    print ''
+    print 'Currently active filters:'
+    for f in pappyproxy.pappy.main_context.active_filters:
+        print '> %s' % f.filter_string
+
+    # We copy so that we're not removing items from a set we're iterating over
+    reqs = list(pappyproxy.pappy.main_context.inactive_requests)
+    act_reqs = list(pappyproxy.pappy.main_context.active_requests)
+    message = 'This will delete %d/%d requests. You can NOT undo this!! Continue?' % (len(reqs), (len(reqs) + len(act_reqs)))
+    if not confirm(message, 'n'):
+        defer.returnValue(None)
+    
+    for r in reqs:
+        yield r.deep_delete()
+    print 'Deleted %d requests' % len(reqs)
+    defer.returnValue(None)
+
+###############
+## Plugin hooks
+
+def load_cmds(cmd):
+    cmd.set_cmds({
+        'filter_prune': (filter_prune, None),
+        'scope_list': (scope_list, None),
+        'scope_delete': (scope_delete, None),
+        'scope_reset': (scope_reset, None),
+        'scope_save': (scope_save, None),
+        'filter_list': (filter_list, None),
+        'filter_clear': (filter_clear, None),
+        'filter_up': (filter_up, None),
+        'builtin_filter': (builtin_filter, complete_builtin_filter),
+        'filter': (filtercmd, None),
+    })
+    cmd.add_aliases([
+        #('filter_prune', ''),
+        ('scope_list', 'sls'),
+        #('scope_delete', ''),
+        ('scope_reset', 'sr'),
+        #('scope_save', ''),
+        ('filter_list', 'fls'),
+        ('filter_clear', 'fc'),
+        ('filter_up', 'fu'),
+        ('builtin_filter', 'fbi'),
+        ('filter', 'f'),
+        ('filter', 'fl'),
+    ])