Example #1
0
class Informer(Runnable):
    info_sites = []
    sleep_time = 60 * 60  # every hour

    db = None
    api = None
    config = None

    def load_configs(self):
        for cfg in self.config.get_site_configs():
            self.db.add_site_configuration(cfg)

    def __init__(self, config):
        Runnable.__init__(self)
        self.db = Database()
        self.config = config
        self.load_configs()
        self.api = API(callback_add=self.callback_add_info_site)
        self.driver = WebDriver.build(config)

    def callback_add_info_site(self, config):
        self.info_sites.append(config)  # todo filter if not already in list
        return True

    def _run(self):
        for i in self.info_sites:
            i.check()

    def stop(self):
        self.api.stop()
Example #2
0
 def __init__(self, config):
     Runnable.__init__(self)
     self.db = Database()
     self.config = config
     self.load_configs()
     self.api = API(callback_add=self.callback_add_info_site)
     self.driver = WebDriver.build(config)
Example #3
0
    def __init__(self):
        """
    initialize the instance
    """
        self.plugins = {}
        self.pluginl = {}
        self.pluginm = {}
        self.pluginp = {}
        self.options = {}
        self.plugininfo = {}

        index = __file__.rfind(os.sep)
        if index == -1:
            self.basepath = "." + os.sep
        else:
            self.basepath = __file__[:index]

        self.api = API()
        self.savefile = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                     'loadedplugins.txt')
        self.loadedplugins = PersistentDict(self.savefile, 'c')
        self.sname = 'plugins'
        self.lname = 'Plugin Manager'

        self.api.add(self.sname, 'isinstalled', self.api_isinstalled)
        self.api.add(self.sname, 'getp', self.api_getp)
        self.api.add(self.sname, 'module', self.api_getmodule)
        self.api.add(self.sname, 'allplugininfo', self.api_allplugininfo)
        self.api.add(self.sname, 'savestate', self.savestate)
Example #4
0
    def __init__(self, name, sname, modpath, basepath, fullimploc):  # pylint: disable=too-many-arguments
        """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
        # Examples:
        #  name : 'Actions' - from plugin file variable NAME (long name)
        #  sname : 'actions' - from plugin file variable SNAME (short name)
        #  modpath : '/client/actions.py' - path relative to the plugins directory
        #  basepath : '/home/src/games/bastproxy/bp/plugins' - the full path to the
        #                                                         plugins directory
        #  fullimploc : 'plugins.client.actions' - import location

        self.author = ''
        self.purpose = ''
        self.version = 0
        self.priority = 100
        self.name = name
        self.sname = sname
        self.dependencies = []
        self.versionfuncs = {}
        self.reloaddependents = False
        self.summarytemplate = "%20s : %s"
        self.canreload = True
        self.canreset = True
        self.resetflag = True
        self.api = API()
        self.firstactiveprio = None
        self.loadedtime = time.time()
        self.savedir = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                    self.sname)
        try:
            os.makedirs(self.savedir)
        except OSError:
            pass
        self.savefile = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                     self.sname, 'settingvalues.txt')
        self.modpath = modpath
        self.basepath = basepath
        self.fullimploc = fullimploc
        self.pluginfile = os.path.join(basepath, modpath[1:])
        self.pluginlocation = os.path.normpath(
            os.path.join(self.api.BASEPATH, 'plugins') + \
              os.sep + os.path.dirname(self.modpath))

        self.package = fullimploc.split('.')[1]

        self.settings = {}
        self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

        self._dump_shallow_attrs = ['api']

        self.api.overload('dependency', 'add', self._api_dependencyadd)
        self.api.overload('setting', 'add', self._api_settingadd)
        self.api.overload('setting', 'gets', self._api_settinggets)
        self.api.overload('setting', 'change', self._api_settingchange)
        self.api.overload('api', 'add', self._api_add)
Example #5
0
    def api_sendpacket(self, message):
        """  send an A102 packet
    @Ymessage@w  = the message to send

    Format: IAC SB A102 <atcp message text> IAC SE

    this function returns no values"""
        from libs.api import API
        api = API()
        api.get('events.eraise')('to_mud_event', {'data':'%s%s%s%s%s%s' % \
              (IAC, SB, A102, message.replace(IAC, IAC+IAC), IAC, SE),
              'raw':True, 'dtype':A102})
Example #6
0
  def api_sendpacket(self, message):
    """  send an A102 packet
    @Ymessage@w  = the message to send

    Format: IAC SB A102 <atcp message text> IAC SE

    this function returns no values"""
    from libs.api import API
    api = API()
    api.get('events.eraise')('to_mud_event', {'data':'%s%s%s%s%s%s' % \
          (IAC, SB, A102, message.replace(IAC, IAC+IAC), IAC, SE),
          'raw':True, 'dtype':A102})
Example #7
0
    def __init__(self, name, sname, modpath, basepath, fullimploc):
        # pylint: disable=too-many-arguments
        """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
        self.author = ''
        self.purpose = ''
        self.version = 0
        self.priority = 100
        self.name = name
        self.sname = sname
        self.dependencies = []
        self.versionfuncs = {}
        self.reloaddependents = False
        self.canreload = True
        self.resetflag = True
        self.api = API()
        self.loadedtime = time.time()
        self.savedir = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                    self.sname)
        try:
            os.makedirs(self.savedir)
        except OSError:
            pass
        self.savefile = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                     self.sname, 'settingvalues.txt')
        self.modpath = modpath
        self.basepath = basepath
        self.fullimploc = fullimploc
        self.pluginfile = os.path.join(basepath, modpath[1:])
        self.pluginlocation = os.path.normpath(
            os.path.join(self.api.BASEPATH, 'plugins') + \
              os.sep + os.path.dirname(self.modpath))

        self.package = fullimploc.split('.')[1]

        self.settings = {}
        self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

        self._dump_shallow_attrs = ['api']

        self.api.overload('dependency', 'add', self.api_dependencyadd)
        self.api.overload('setting', 'add', self.api_settingadd)
        self.api.overload('setting', 'gets', self.api_settinggets)
        self.api.overload('setting', 'change', self.api_settingchange)
        self.api.overload('api', 'add', self.api_add)
Example #8
0
    def __init__(self, sock, host, port):
        """
    init the class
    """
        Telnet.__init__(self, sock=sock)
        self.host = host
        self.port = port
        self.api = API()
        self.ttype = 'Client'
        self.connectedtime = None
        self.supports = {}
        self.pwtries = 0
        self.banned = False
        self.viewonly = False

        if sock:
            self.connected = True
            self.connectedtime = time.mktime(time.localtime())

        self.api('events.register')('to_client_event',
                                    self.addtooutbufferevent,
                                    prio=99)

        self.api('options.prepareclient')(self)

        self.state = PASSWORD
        self.addtooutbufferevent({
            'original':
            self.api('colors.convertcolors')(
                '@R#BP@w: @RPlease enter the proxy password:@w'),
            'dtype':
            'passwd'
        })
Example #9
0
    def __init__(self, host=None, port=0, sock=None):
        """
    Constructor.

    When called without arguments, create an unconnected instance.
    With a hostname argument, it connects the instance; port number
    and timeout are optional.
    """
        if sock:
            asyncore.dispatcher.__init__(self, sock)
        else:
            asyncore.dispatcher.__init__(self)
        self.sock = sock
        self.debuglevel = DEBUGLEVEL
        self.host = host
        self.port = port
        self.rawq = ''
        self.api = API()
        self.cookedq = ''
        self.eof = 0
        self.sbdataq = ''
        self._sbdatabuffer = ''
        self.outbuffer = ''
        self.options = {}
        self.option_callback = self.handleopt
        self.option_handlers = {}
        self.connected = False
        self.ttype = 'Unknown'
        self.debug_types = []
Example #10
0
  def __init__(self, name, sname, modpath, basepath, fullimploc): # pylint: disable=too-many-arguments
    """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
    # Examples:
    #  name : 'Actions' - from plugin file variable NAME (long name)
    #  sname : 'actions' - from plugin file variable SNAME (short name)
    #  modpath : '/client/actions.py' - path relative to the plugins directory
    #  basepath : '/home/src/games/bastproxy/bp/plugins' - the full path to the
    #                                                         plugins directory
    #  fullimploc : 'plugins.client.actions' - import location

    self.author = ''
    self.purpose = ''
    self.version = 0
    self.priority = 100
    self.name = name
    self.sname = sname
    self.dependencies = []
    self.versionfuncs = {}
    self.reloaddependents = False
    self.summarytemplate = "%20s : %s"
    self.canreload = True
    self.canreset = True
    self.resetflag = True
    self.api = API()
    self.firstactiveprio = None
    self.loadedtime = time.time()
    self.savedir = os.path.join(self.api.BASEPATH, 'data',
                                'plugins', self.sname)
    try:
      os.makedirs(self.savedir)
    except OSError:
      pass
    self.savefile = os.path.join(self.api.BASEPATH, 'data',
                                 'plugins', self.sname, 'settingvalues.txt')
    self.modpath = modpath
    self.basepath = basepath
    self.fullimploc = fullimploc
    self.pluginfile = os.path.join(basepath, modpath[1:])
    self.pluginlocation = os.path.normpath(
        os.path.join(self.api.BASEPATH, 'plugins') + \
          os.sep + os.path.dirname(self.modpath))

    self.package = fullimploc.split('.')[1]

    self.settings = {}
    self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

    self._dump_shallow_attrs = ['api']

    self.api.overload('dependency', 'add', self._api_dependencyadd)
    self.api.overload('setting', 'add', self._api_settingadd)
    self.api.overload('setting', 'gets', self._api_settinggets)
    self.api.overload('setting', 'change', self._api_settingchange)
    self.api.overload('api', 'add', self._api_add)
 def __init__(self, telnetobj, option):
   """
   initalize the instance
   """
   self.api = API()
   self.telnetobj = telnetobj
   self.option = option
   self.telnetobj.option_handlers[ord(self.option)] = self
Example #12
0
 def __init__(self, telnetobj, option, plugin):
     """
 initalize the instance
 """
     tapi = API()
     self.telnetobj = telnetobj
     self.option = option
     self.telnetobj.option_handlers[ord(self.option)] = self
     self.plugin = tapi('plugins.getp')(plugin)
Example #13
0
 def __init__(self):
     """
 initialize the class
 """
     self.currenttrace = None
     self.api = API()
     self.api('api.add')('send', 'msg', self._api_msg)
     self.api('api.add')('send', 'error', self._api_error)
     self.api('api.add')('send', 'traceback', self._api_traceback)
     self.api('api.add')('send', 'client', self._api_client)
     self.api('api.add')('send', 'mud', self._api_tomud)
     self.api('api.add')('send', 'execute', self._api_execute)
     self.api('managers.add')('io', self)
Example #14
0
  def __init__(self, name, sname, modpath, basepath, fullimploc):
    # pylint: disable=too-many-arguments
    """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
    self.author = ''
    self.purpose = ''
    self.version = 0
    self.priority = 100
    self.name = name
    self.sname = sname
    self.dependencies = []
    self.versionfuncs = {}
    self.reloaddependents = False
    self.canreload = True
    self.resetflag = True
    self.api = API()
    self.loadedtime = time.time()
    self.savedir = os.path.join(self.api.BASEPATH, 'data',
                                'plugins', self.sname)
    try:
      os.makedirs(self.savedir)
    except OSError:
      pass
    self.savefile = os.path.join(self.api.BASEPATH, 'data',
                                 'plugins', self.sname, 'settingvalues.txt')
    self.modpath = modpath
    self.basepath = basepath
    self.fullimploc = fullimploc
    self.pluginfile = os.path.join(basepath, modpath[1:])
    self.pluginlocation = os.path.normpath(
        os.path.join(self.api.BASEPATH, 'plugins') + \
          os.sep + os.path.dirname(self.modpath))

    self.package = fullimploc.split('.')[1]

    self.settings = {}
    self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

    self._dump_shallow_attrs = ['api']

    self.api.overload('dependency', 'add', self.api_dependencyadd)
    self.api.overload('setting', 'add', self.api_settingadd)
    self.api.overload('setting', 'gets', self.api_settinggets)
    self.api.overload('setting', 'change', self.api_settingchange)
    self.api.overload('api', 'add', self.api_add)
Example #15
0
    def __init__(self):
        """
    init the class
    """
        Telnet.__init__(self)

        self.username = None
        self.password = None
        self.api = API()
        self.lastmsg = ''
        self.clients = []
        self.vclients = []
        self.ttype = 'BastProxy'
        self.banned = {}
        self.connectedtime = None
        self.api('events.register')('to_mud_event',
                                    self.addtooutbuffer,
                                    prio=99)
        self.api('options.prepareserver')(self)
Example #16
0
  def __init__(self, filename, flag='c', mode=None,
               tformat='json', *args, **kwds):
    """
    initialize the instance
    """
    self._dump_shallow_attrs = ['api']
    self.api = API()

    # r=readonly, c=create, or n=new
    self.flag = flag

    # None or an octal triple like 0644
    self.mode = (stat.S_IWUSR | stat.S_IRUSR) or mode

    # 'csv', 'json', or 'pickle'
    self.format = tformat
    self.filename = filename
    self.pload()
    dict.__init__(self, *args, **kwds)
Example #17
0
"""
handle output and input functions, adds items under the send api
"""
import time
import sys
import traceback
import re
from libs.api import API as BASEAPI

API = BASEAPI()


# send a message
def api_msg(tmsg, primary='default', secondary=None):
    """  send a message through the log plugin
    @Ymsg@w        = This message to send
    @Yprimary@w    = the primary datatype of the message (default: 'default')
    @Ysecondary@w  = the secondary datatype of the message
                        (default: 'None')

  this function returns no values"""
    if primary == 'default':
        try:
            primary = API('utils.funccallerplugin')() or primary
        except (AttributeError, RuntimeError):
            pass

    if not isinstance(secondary, list):
        tmpl = []
        if secondary:
            tmpl.append(secondary)
Example #18
0
class PluginMgr(object):
    # pylint: disable=too-many-public-methods
    """
  a class to manage plugins
  """
    def __init__(self):
        """
    initialize the instance
    """
        self.plugins = {}
        self.pluginl = {}
        self.pluginm = {}
        self.pluginp = {}
        self.options = {}
        self.plugininfo = {}

        index = __file__.rfind(os.sep)
        if index == -1:
            self.basepath = "." + os.sep
        else:
            self.basepath = __file__[:index]

        self.api = API()
        self.savefile = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                     'loadedplugins.txt')
        self.loadedplugins = PersistentDict(self.savefile, 'c')
        self.sname = 'plugins'
        self.lname = 'Plugin Manager'

        self.api.add(self.sname, 'isinstalled', self.api_isinstalled)
        self.api.add(self.sname, 'getp', self.api_getp)
        self.api.add(self.sname, 'module', self.api_getmodule)
        self.api.add(self.sname, 'allplugininfo', self.api_allplugininfo)
        self.api.add(self.sname, 'savestate', self.savestate)

    # return the dictionary of all plugins
    def api_allplugininfo(self):
        """
    return the plugininfo dictionary
    """
        return self.plugininfo

    def findplugin(self, name):
        """
    find a plugin file
    """
        if '.' in name:
            tlist = name.split('.')
            name = tlist[-1]
            del tlist[-1]
            npath = os.sep.join(tlist)

        _module_list = find_files(self.basepath, name + ".py")

        if len(_module_list) == 1:
            return _module_list[0], self.basepath
        else:
            for i in _module_list:
                if npath in i:
                    return i, self.basepath

        return '', ''

    def findloadedplugin(self, plugin):
        """
    find a plugin
    """
        if plugin and plugin in self.plugins:
            return plugin

        fullimploc = 'plugins.' + plugin
        for tplugin in self.plugins:
            if self.plugins[tplugin].fullimploc == fullimploc:
                return tplugin

        return None

    # get a plugin instance
    def api_getmodule(self, pluginname):
        """  returns the module of a plugin
    @Ypluginname@w  = the plugin to check for"""
        if pluginname in self.pluginm:
            return self.pluginm[pluginname]

        return None

    # get a plugin instance
    def api_getp(self, pluginname):
        """  get a plugin instance
    @Ypluginname@w  = the plugin to get for"""

        if isinstance(pluginname, basestring):
            if pluginname in self.plugins:
                return self.plugins[pluginname]
            if pluginname in self.pluginl:
                return self.pluginl[pluginname]
            if pluginname in self.pluginm:
                return self.pluginm[pluginname]
            if pluginname in self.pluginp:
                return self.pluginp[pluginname]
        elif isinstance(pluginname, BasePlugin):
            return pluginname

        return None

    # check if a plugin is installed
    def api_isinstalled(self, pluginname):
        """  check if a plugin is installed
    @Ypluginname@w  = the plugin to check for"""
        if pluginname in self.plugins or pluginname in self.pluginl:
            return True
        return False

    def loaddependencies(self, pluginname, dependencies):
        """
    load a list of modules
    """
        for i in dependencies:
            if i in self.plugins or i in self.pluginl:
                continue

            self.api.get('send.msg')('%s: loading dependency %s' %
                                     (pluginname, i), pluginname)

            name, path = self.findplugin(i)
            if name:
                modpath = name.replace(path, '')
                self.load_module(modpath, path, force=True)

    def getnotloadedplugins(self):
        """
    create a message of all not loaded plugins
    """
        msg = []
        badplugins = self.updateallplugininfo()
        for modpath in sorted(self.plugininfo.keys()):
            sname = self.plugininfo[modpath]['sname']
            fullimploc = self.plugininfo[modpath]['fullimploc']
            if sname not in self.plugins:
                msg.append("%-20s : %-25s %-10s %-5s %s@w" % \
                          (fullimploc.replace('plugins.', ''),
                           self.plugininfo[modpath]['name'],
                           self.plugininfo[modpath]['author'],
                           self.plugininfo[modpath]['version'],
                           self.plugininfo[modpath]['purpose']))
        if len(msg) > 0:
            msg.insert(0, '-' * 75)
            msg.insert(0, "%-20s : %-25s %-10s %-5s %s@w" % \
                                ('Location', 'Name', 'Author', 'Vers', 'Purpose'))
            msg.insert(0, 'The following plugins are not loaded')

        if badplugins:
            msg.append('')
            msg.append('The following files would not import')
            for bad in badplugins:
                msg.append(bad.replace('plugins.', ''))

        return msg

    def getchangedplugins(self):
        """
    create a message of plugins that are changed on disk
    """
        msg = []

        plugins = sorted(self.plugins.values(),
                         key=operator.attrgetter('package'))
        packageheader = []

        msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                            ('Short Name', 'Name', 'Author', 'Vers', 'Purpose'))
        msg.append('-' * 75)
        for tpl in plugins:
            if tpl.ischangedondisk():
                if tpl.package not in packageheader:
                    if len(packageheader) > 0:
                        msg.append('')
                    packageheader.append(tpl.package)
                    limp = 'plugins.%s' % tpl.package
                    mod = __import__(limp)
                    try:
                        desc = getattr(mod, tpl.package).DESCRIPTION
                    except AttributeError:
                        desc = ''
                    msg.append('@GPackage: %s%s@w' % \
                            (tpl.package, ' - ' + desc if desc else ''))
                    msg.append('@G' + '-' * 75 + '@w')
                msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                          (tpl.sname, tpl.name,
                           tpl.author, tpl.version, tpl.purpose))

        return msg

    def getpackageplugins(self, package):
        """
    create a message of plugins in a package
    """
        msg = []

        plist = []
        for plugin in self.plugins.values():
            if plugin.package == package:
                plist.append(plugin)

        if len(plist) > 0:
            plugins = sorted(plist, key=operator.attrgetter('sname'))
            limp = 'plugins.%s' % package
            mod = __import__(limp)
            try:
                desc = getattr(mod, package).DESCRIPTION
            except AttributeError:
                desc = ''
            msg.append('@GPackage: %s%s@w' % \
                  (package, ' - ' + desc if desc else ''))
            msg.append('@G' + '-' * 75 + '@w')
            msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                                ('Short Name', 'Name',
                                 'Author', 'Vers', 'Purpose'))
            msg.append('-' * 75)

            for tpl in plugins:
                msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                          (tpl.sname, tpl.name,
                           tpl.author, tpl.version, tpl.purpose))
        else:
            msg.append('That is not a valid package')

        return msg

    def getallplugins(self):
        """
    create a message of all plugins
    """
        msg = []

        plugins = sorted(self.plugins.values(),
                         key=operator.attrgetter('package'))
        packageheader = []
        msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                            ('Short Name', 'Name', 'Author', 'Vers', 'Purpose'))
        msg.append('-' * 75)
        for tpl in plugins:
            if tpl.package not in packageheader:
                if len(packageheader) > 0:
                    msg.append('')
                packageheader.append(tpl.package)
                limp = 'plugins.%s' % tpl.package
                mod = __import__(limp)
                try:
                    desc = getattr(mod, tpl.package).DESCRIPTION
                except AttributeError:
                    desc = ''
                msg.append('@GPackage: %s%s@w' % \
                    (tpl.package, ' - ' + desc if desc else ''))
                msg.append('@G' + '-' * 75 + '@w')
            msg.append("%-10s : %-25s %-10s %-5s %s@w" % \
                        (tpl.sname, tpl.name,
                         tpl.author, tpl.version, tpl.purpose))
        return msg

    def cmd_list(self, args):
        """
    @G%(name)s@w - @B%(cmdname)s@w
      List plugins
      @CUsage@w: list
    """
        msg = []

        if args['notloaded']:
            msg.extend(self.getnotloadedplugins())
        elif args['changed']:
            msg.extend(self.getchangedplugins())
        elif args['package']:
            msg.extend(self.getpackageplugins(args['package']))
        else:
            msg.extend(self.getallplugins())
        return True, msg

    def cmd_load(self, args):
        """
    @G%(name)s@w - @B%(cmdname)s@w
      Load a plugin
      @CUsage@w: load @Yplugin@w
        @Yplugin@w    = the name of the plugin to load
               use the name without the .py
    """
        tmsg = []
        plugin = args['plugin']
        if plugin:

            fname = plugin.replace('.', os.sep)
            _module_list = find_files(self.basepath, fname + ".py")

            if len(_module_list) > 1:
                tmsg.append('There is more than one module that matches: %s' % \
                                                                      plugin)
            elif len(_module_list) == 0:
                tmsg.append('There are no modules that match: %s' % plugin)
            else:
                modpath = _module_list[0].replace(self.basepath, '')
                sname, reason = self.load_module(modpath, self.basepath, True)
                if sname:
                    if reason == 'already':
                        tmsg.append('Module %s is already loaded' % sname)
                    else:
                        tmsg.append('Load complete: %s - %s' % \
                                                      (sname, self.plugins[sname].name))
                else:
                    tmsg.append('Could not load: %s' % plugin)
            return True, tmsg
        else:
            return False, ['@Rplease specify a plugin@w']

    def cmd_unload(self, args):
        """
    @G%(name)s@w - @B%(cmdname)s@w
      unload a plugin
      @CUsage@w: unload @Yplugin@w
        @Yplugin@w    = the shortname of the plugin to load
    """
        tmsg = []
        plugina = args['plugin']

        if not plugina:
            return False, ['@Rplease specify a plugin@w']

        plugin = self.findloadedplugin(plugina)

        if plugin and plugin in self.plugins:
            if self.plugins[plugin].canreload:
                if self.unload_module(self.plugins[plugin].fullimploc):
                    tmsg.append("Unloaded: %s" % plugin)
                else:
                    tmsg.append("Could not unload:: %s" % plugin)
            else:
                tmsg.append("That plugin can not be unloaded")
            return True, tmsg
        elif plugin:
            tmsg.append('plugin %s does not exist' % plugin)
            return True, tmsg

        return False, ['@Rplease specify a plugin@w']

    def cmd_reload(self, args):
        """
    @G%(name)s@w - @B%(cmdname)s@w
      reload a plugin
      @CUsage@w: reload @Yplugin@w
        @Yplugin@w    = the shortname of the plugin to reload
    """
        tmsg = []
        plugina = args['plugin']

        if not plugina:
            return False, ['@Rplease specify a plugin@w']

        plugin = self.findloadedplugin(plugina)

        if plugin and plugin in self.plugins:
            if self.plugins[plugin].canreload:
                tret, _ = self.reload_module(plugin, True)
                if tret and tret != True:
                    tmsg.append("Reload complete: %s" %
                                self.plugins[tret].fullimploc)
                    return True, tmsg
            else:
                tmsg.append("That plugin cannot be reloaded")
                return True, tmsg
        else:
            tmsg.append('plugin %s does not exist' % plugin)
            return True, tmsg

        return False, tmsg

    def load_modules(self, tfilter):
        """
    load modules in all directories under plugins
    """
        _module_list = find_files(self.basepath, tfilter)
        _module_list.sort()

        load = False

        for fullpath in _module_list:
            modpath = fullpath.replace(self.basepath, '')
            force = False
            if modpath in self.loadedplugins:
                force = True
            modname, dummy = self.load_module(modpath,
                                              self.basepath,
                                              force=force,
                                              runload=load)

            if modname == 'log':
                self.api.get('log.adddtype')(self.sname)
                self.api.get('log.console')(self.sname)
                self.api.get('log.adddtype')('upgrade')
                self.api.get('log.console')('upgrade')

        if not load:
            testsort = sorted(self.plugins.values(),
                              key=operator.attrgetter('priority'))
            for i in testsort:
                try:
                    #check dependencies here
                    self.loadplugin(i)
                except Exception:  # pylint: disable=broad-except
                    self.api.get('send.traceback')(
                        "load: had problems running the load method for %s." \
                                    % i.fullimploc)
                    del sys.modules[i.fullimploc]

    def updateallplugininfo(self):
        """
    find plugins that are not in self.plugininfo
    """
        _module_list = find_files(self.basepath, '*.py')
        _module_list.sort()

        self.plugininfo = {}
        badplugins = []

        for fullpath in _module_list:
            modpath = fullpath.replace(self.basepath, '')

            imploc, modname = get_module_name(modpath)

            if not modname.startswith("_"):
                fullimploc = "plugins" + '.' + imploc
                if fullimploc in sys.modules:
                    self.plugininfo[modpath] = {}
                    self.plugininfo[modpath]['sname'] = self.pluginp[
                        modpath].sname
                    self.plugininfo[modpath]['name'] = self.pluginp[
                        modpath].name
                    self.plugininfo[modpath]['purpose'] = self.pluginp[
                        modpath].purpose
                    self.plugininfo[modpath]['author'] = self.pluginp[
                        modpath].author
                    self.plugininfo[modpath]['version'] = self.pluginp[
                        modpath].version
                    self.plugininfo[modpath]['modpath'] = modpath
                    self.plugininfo[modpath]['fullimploc'] = fullimploc

                else:
                    try:
                        _module = __import__(fullimploc)
                        _module = sys.modules[fullimploc]

                        self.plugininfo[modpath] = {}
                        self.plugininfo[modpath]['sname'] = _module.SNAME
                        self.plugininfo[modpath]['name'] = _module.NAME
                        self.plugininfo[modpath]['purpose'] = _module.PURPOSE
                        self.plugininfo[modpath]['author'] = _module.AUTHOR
                        self.plugininfo[modpath]['version'] = _module.VERSION
                        self.plugininfo[modpath]['modpath'] = modpath
                        self.plugininfo[modpath]['fullimploc'] = fullimploc

                        del sys.modules[fullimploc]

                    except Exception:  # pylint: disable=broad-except
                        badplugins.append(fullimploc)

        return badplugins

    def load_module(self, modpath, basepath, force=False, runload=True):
        # pylint: disable=too-many-branches
        """
    load a single module
    """
        if basepath in modpath:
            modpath = modpath.replace(basepath, '')

        imploc, modname = get_module_name(modpath)

        if modname.startswith("_"):
            return False, 'dev'

        try:
            fullimploc = "plugins" + '.' + imploc
            if fullimploc in sys.modules:
                return sys.modules[fullimploc].SNAME, 'already'

            self.api.get('send.msg')('importing %s' % fullimploc, self.sname)
            _module = __import__(fullimploc)
            _module = sys.modules[fullimploc]
            self.api.get('send.msg')('imported %s' % fullimploc, self.sname)
            load = True

            if 'AUTOLOAD' in _module.__dict__ and not force:
                if not _module.AUTOLOAD:
                    load = False
            elif 'AUTOLOAD' not in _module.__dict__:
                load = False

            if modpath not in self.plugininfo:
                self.plugininfo[modpath] = {}
                self.plugininfo[modpath]['sname'] = _module.SNAME
                self.plugininfo[modpath]['name'] = _module.NAME
                self.plugininfo[modpath]['purpose'] = _module.PURPOSE
                self.plugininfo[modpath]['author'] = _module.AUTHOR
                self.plugininfo[modpath]['version'] = _module.VERSION
                self.plugininfo[modpath]['modpath'] = modpath
                self.plugininfo[modpath]['fullimploc'] = fullimploc

            if load:
                if "Plugin" in _module.__dict__:
                    self.add_plugin(_module, modpath, basepath, fullimploc,
                                    runload)

                else:
                    self.api.get('send.msg')('Module %s has no Plugin class' % \
                                                        _module.NAME,
                                             self.sname)

                _module.__dict__["proxy_import"] = 1

                return _module.SNAME, 'Loaded'
            else:
                if fullimploc in sys.modules:
                    del sys.modules[fullimploc]
                self.api.get('send.msg')(
                    'Not loading %s (%s) because autoload is False' % \
                                            (_module.NAME, fullimploc),
                    self.sname)
            return True, 'not autoloaded'
        except Exception:  # pylint: disable=broad-except
            if fullimploc in sys.modules:
                del sys.modules[fullimploc]

            self.api.get('send.traceback')(
                "Module '%s' refuses to import/load." % fullimploc)
            return False, 'error'

    def unload_module(self, fullimploc):
        """
    unload a module
    """
        if fullimploc in sys.modules:

            _module = sys.modules[fullimploc]
            try:
                if "proxy_import" in _module.__dict__:
                    self.api.get('send.client')('unload: unloading %s' %
                                                fullimploc)
                    if "unload" in _module.__dict__:
                        try:
                            _module.unload()
                        except Exception:  # pylint: disable=broad-except
                            self.api.get('send.traceback')(
                                "unload: module %s didn't unload properly." %
                                fullimploc)

                    if not self.remove_plugin(_module.SNAME):
                        self.api.get('send.client')(
                            'could not remove plugin %s' % fullimploc)

                del sys.modules[fullimploc]
                self.api.get('send.client')("unload: unloaded %s." %
                                            fullimploc)

            except Exception:  # pylint: disable=broad-except
                self.api.get('send.traceback')(
                    "unload: had problems unloading %s." % fullimploc)
                return False

        return True

    def reload_module(self, modname, force=False):
        """
    reload a module
    """
        if modname in self.plugins:
            plugin = self.plugins[modname]
            fullimploc = plugin.fullimploc
            basepath = plugin.basepath
            modpath = plugin.modpath
            sname = plugin.sname
            try:
                reloaddependents = plugin.reloaddependents
            except Exception:  # pylint: disable=broad-except
                reloaddependents = False
            plugin = None
            if not self.unload_module(fullimploc):
                return False, ''

            if modpath and basepath:
                retval = self.load_module(modpath, basepath, force)
                if retval and reloaddependents:
                    self.reloaddependents(sname)
                return retval

        else:
            return False, ''

    def reloaddependents(self, reloadedplugin):
        """
    reload all dependents
    """
        testsort = sorted(self.plugins.values(),
                          key=operator.attrgetter('priority'))
        for plugin in testsort:
            if plugin.sname != reloadedplugin:
                if reloadedplugin in plugin.dependencies:
                    self.api.get('send.msg')('reloading dependent %s of %s' % \
                                (plugin.sname, reloadedplugin))
                    plugin.savestate()
                    self.reload_module(plugin.sname, True)

    def loadplugin(self, plugin):
        """
    check dependencies and run the load function
    """
        self.api.get('send.msg')('loading dependencies for %s' % \
                                      plugin.fullimploc,
                                 self.sname)
        self.loaddependencies(plugin.sname, plugin.dependencies)
        self.api.get('send.client')("load: loading %s with priority %s" % \
           (plugin.fullimploc, plugin.priority))
        self.api.get('send.msg')('loading %s (%s: %s)' % \
                  (plugin.fullimploc, plugin.sname, plugin.name),
                                 self.sname)
        plugin.load()
        self.api.get('send.client')("load: loaded %s" % plugin.fullimploc)
        self.api.get('send.msg')('loaded %s (%s: %s)' % \
                  (plugin.fullimploc, plugin.sname, plugin.name),
                                 self.sname)

        self.api.get('events.eraise')('%s_plugin_loaded' % plugin.sname, {})
        self.api.get('events.eraise')('plugin_loaded', {
            'plugin': plugin.sname
        })

    def add_plugin(self, module, modpath, basepath, fullimploc, load=True):
        # pylint: disable=too-many-arguments
        """
    add a plugin to be managed
    """
        module.__dict__["lyntin_import"] = 1
        plugin = module.Plugin(module.NAME, module.SNAME, modpath, basepath,
                               fullimploc)
        plugin.author = module.AUTHOR
        plugin.purpose = module.PURPOSE
        plugin.version = module.VERSION
        try:
            plugin.priority = module.PRIORITY
        except AttributeError:
            pass
        if plugin.name in self.pluginl:
            self.api.get('send.msg')('Plugin %s already exists' % plugin.name,
                                     self.sname)
            return False
        if plugin.sname in self.plugins:
            self.api.get('send.msg')('Plugin %s already exists' % plugin.sname,
                                     self.sname)
            return False

        if load:
            try:
                #check dependencies here
                self.loadplugin(plugin)
            except Exception:  # pylint: disable=broad-except
                self.api.get('send.traceback')(
                    "load: had problems running the load method for %s." \
                                                        % fullimploc)
                del sys.modules[fullimploc]
                return False
        self.pluginl[plugin.name] = plugin
        self.plugins[plugin.sname] = plugin
        self.pluginm[plugin.sname] = module
        self.pluginp[modpath] = plugin
        self.loadedplugins[modpath] = True
        self.loadedplugins.sync()

        return True

    def remove_plugin(self, pluginname):
        """
    remove a plugin
    """
        plugin = None
        if pluginname in self.plugins:
            plugin = self.plugins[pluginname]
            try:
                plugin.unload()
                self.api.get('events.eraise')('%s_plugin_unload' %
                                              plugin.sname, {})
                self.api.get('events.eraise')('plugin_unloaded', {
                    'name': plugin.sname
                })
                self.api.get('send.msg')('Plugin %s unloaded' % plugin.sname,
                                         self.sname, plugin.sname)
            except Exception:  # pylint: disable=broad-except
                self.api.get('send.traceback')(
                    "unload: had problems running the unload method for %s." \
                                          % plugin.sname)
                return False

            del self.plugins[plugin.sname]
            del self.pluginl[plugin.name]
            del self.pluginm[plugin.sname]
            del self.loadedplugins[plugin.modpath]
            self.loadedplugins.sync()

            plugin = None

            return True
        else:
            return False

    # save all plugins
    def savestate(self):
        """
    save all plugins
    """
        for i in self.plugins:
            self.plugins[i].savestate()

    def load(self):
        """
    load various things
    """
        self.load_modules("*.py")

        parser = argparse.ArgumentParser(add_help=False,
                                         description="list plugins")
        parser.add_argument('-n',
                            "--notloaded",
                            help="list plugins that are not loaded",
                            action="store_true")
        parser.add_argument(
            '-c',
            "--changed",
            help="list plugins that are load but are changed on disk",
            action="store_true")
        parser.add_argument('package',
                            help='the to list',
                            default='',
                            nargs='?')
        self.api.get('commands.add')('list',
                                     self.cmd_list,
                                     lname='Plugin Manager',
                                     parser=parser)

        parser = argparse.ArgumentParser(add_help=False,
                                         description="load a plugin")
        parser.add_argument('plugin',
                            help='the plugin to load, don\'t include the .py',
                            default='',
                            nargs='?')
        self.api.get('commands.add')('load',
                                     self.cmd_load,
                                     lname='Plugin Manager',
                                     parser=parser)

        parser = argparse.ArgumentParser(add_help=False,
                                         description="unload a plugin")
        parser.add_argument('plugin',
                            help='the plugin to unload',
                            default='',
                            nargs='?')
        self.api.get('commands.add')('unload',
                                     self.cmd_unload,
                                     lname='Plugin Manager',
                                     parser=parser)

        parser = argparse.ArgumentParser(add_help=False,
                                         description="reload a plugin")
        parser.add_argument('plugin',
                            help='the plugin to reload',
                            default='',
                            nargs='?')
        self.api.get('commands.add')('reload',
                                     self.cmd_reload,
                                     lname='Plugin Manager',
                                     parser=parser)

        self.api.get('commands.default')('list', self.sname)
        self.api.get('events.register')('savestate',
                                        self.savestate,
                                        plugin=self.sname)

        self.api.get('timers.add')('save',
                                   self.savestate,
                                   60,
                                   nodupe=True,
                                   log=False)
Example #19
0
class BasePlugin(object):  # pylint: disable=too-many-instance-attributes
    """
  a base class for plugins
  """
    def __init__(self, name, sname, modpath, basepath, fullimploc):  # pylint: disable=too-many-arguments
        """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
        # Examples:
        #  name : 'Actions' - from plugin file variable NAME (long name)
        #  sname : 'actions' - from plugin file variable SNAME (short name)
        #  modpath : '/client/actions.py' - path relative to the plugins directory
        #  basepath : '/home/src/games/bastproxy/bp/plugins' - the full path to the
        #                                                         plugins directory
        #  fullimploc : 'plugins.client.actions' - import location

        self.author = ''
        self.purpose = ''
        self.version = 0
        self.priority = 100
        self.name = name
        self.sname = sname
        self.dependencies = []
        self.versionfuncs = {}
        self.reloaddependents = False
        self.summarytemplate = "%20s : %s"
        self.canreload = True
        self.canreset = True
        self.resetflag = True
        self.api = API()
        self.firstactiveprio = None
        self.loadedtime = time.time()
        self.savedir = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                    self.sname)
        try:
            os.makedirs(self.savedir)
        except OSError:
            pass
        self.savefile = os.path.join(self.api.BASEPATH, 'data', 'plugins',
                                     self.sname, 'settingvalues.txt')
        self.modpath = modpath
        self.basepath = basepath
        self.fullimploc = fullimploc
        self.pluginfile = os.path.join(basepath, modpath[1:])
        self.pluginlocation = os.path.normpath(
            os.path.join(self.api.BASEPATH, 'plugins') + \
              os.sep + os.path.dirname(self.modpath))

        self.package = fullimploc.split('.')[1]

        self.settings = {}
        self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

        self._dump_shallow_attrs = ['api']

        self.api.overload('dependency', 'add', self._api_dependencyadd)
        self.api.overload('setting', 'add', self._api_settingadd)
        self.api.overload('setting', 'gets', self._api_settinggets)
        self.api.overload('setting', 'change', self._api_settingchange)
        self.api.overload('api', 'add', self._api_add)

    def _loadcommands(self):
        """
    load the commands
    """
        parser = argp.ArgumentParser(
            add_help=False,
            formatter_class=argp.RawDescriptionHelpFormatter,
            description=textwrap.dedent("""
          change a setting in the plugin

          if there are no arguments or 'list' is the first argument then
          it will list the settings for the plugin"""))
        parser.add_argument('name',
                            help='the setting name',
                            default='list',
                            nargs='?')
        parser.add_argument('value',
                            help='the new value of the setting',
                            default='',
                            nargs='?')
        self.api('commands.add')('set',
                                 self._cmd_set,
                                 parser=parser,
                                 group='Base',
                                 showinhistory=False)

        if self.canreset:
            parser = argp.ArgumentParser(add_help=False,
                                         description='reset the plugin')
            self.api('commands.add')('reset',
                                     self._cmd_reset,
                                     parser=parser,
                                     group='Base')

        parser = argp.ArgumentParser(add_help=False,
                                     description='save the plugin state')
        self.api('commands.add')('save',
                                 self._cmd_save,
                                 parser=parser,
                                 group='Base')

        parser = argp.ArgumentParser(add_help=False,
                                     description='show plugin stats')
        self.api('commands.add')('stats',
                                 self._cmd_stats,
                                 parser=parser,
                                 group='Base')

        parser = argp.ArgumentParser(add_help=False,
                                     description='inspect a plugin')
        parser.add_argument('-m',
                            "--method",
                            help="get code for a method",
                            default='')
        parser.add_argument(
            '-o',
            "--object",
            help="show an object of the plugin, can be method or variable",
            default='')
        parser.add_argument('-s',
                            "--simple",
                            help="show a simple output",
                            action="store_true")
        self.api('commands.add')('inspect',
                                 self._cmd_inspect,
                                 parser=parser,
                                 group='Base')

        parser = argp.ArgumentParser(
            add_help=False, description='show help info for this plugin')
        parser.add_argument('-a',
                            "--api",
                            help="show functions this plugin has in the api",
                            action="store_true")
        parser.add_argument('-c',
                            "--commands",
                            help="show commands in this plugin",
                            action="store_true")
        self.api('commands.add')('help',
                                 self._cmd_help,
                                 parser=parser,
                                 group='Base')

        parser = argp.ArgumentParser(add_help=False,
                                     description='list functions in the api')
        parser.add_argument('api',
                            help='api to get details of',
                            default='',
                            nargs='?')
        self.api('commands.add')('api',
                                 self._cmd_api,
                                 parser=parser,
                                 group='Base')

    def load(self):
        """
    load stuff, do most things here
    """
        self.settingvalues.pload()

        if '_version' in self.settingvalues and \
            self.settingvalues['_version'] != self.version:
            self._updateversion(self.settingvalues['_version'], self.version)

        self.api('log.adddtype')(self.sname)

        self._loadcommands()

        self.api('events.register')('%s_plugin_loaded' % self.sname,
                                    self.__afterload)

        self.api('events.register')('muddisconnect', self.__disconnect)
        self.api('events.register')('plugin_%s_savestate' % self.sname,
                                    self.__savestate)

        self.resetflag = False

    def _updateversion(self, oldversion, newversion):
        """
    update plugin data
    """
        if oldversion != newversion and newversion > oldversion:
            for i in range(oldversion + 1, newversion + 1):
                self.api('send.msg')('%s: upgrading to version %s' %
                                     (self.sname, i),
                                     secondary='upgrade')
                if i in self.versionfuncs:
                    self.versionfuncs[i]()
                else:
                    self.api('send.msg')(
                        '%s: no function to upgrade to version %s' %
                        (self.sname, i),
                        secondary='upgrade')

        self.settingvalues.sync()

    def _cmd_inspect(self, args):  # pylint: disable=too-many-branches
        """
    show the plugin as it currently is in memory
    """
        from libs.objectdump import dumps as dumper

        tmsg = []
        if args['method']:
            try:
                tmeth = getattr(self, args['method'])
                tmsg.append(inspect.getsource(tmeth))
            except AttributeError:
                tmsg.append('There is no method named %s' % args['method'])

        elif args['object']:
            tobj = args['object']
            key = None
            if ':' in tobj:
                tobj, key = tobj.split(':')

            obj = getattr(self, tobj)
            if obj:
                if key:
                    if key not in obj:
                        try:
                            key = int(key)
                        except ValueError:
                            pass
                    if key in obj:
                        obj = obj[key]
                if args['simple']:
                    tvars = pprint.pformat(obj)
                else:
                    tvars = dumper(obj)
                tmsg.append(tvars)

        else:
            if args['simple']:
                tvars = pprint.pformat(vars(self))
            else:
                tvars = dumper(self)

            tmsg.append('@M' + '-' * 60 + '@x')
            tmsg.append('Variables')
            tmsg.append('@M' + '-' * 60 + '@x')
            tmsg.append(tvars)
            tmsg.append('@M' + '-' * 60 + '@x')
            tmsg.append('Methods')
            tmsg.append('@M' + '-' * 60 + '@x')
            tmsg.append(
                pprint.pformat(inspect.getmembers(self, inspect.ismethod)))

        return True, tmsg

    def _cmd_api(self, args):
        """
    list functions in the api for a plugin
    """
        tmsg = []
        if args['api']:
            tmsg.extend(
                self.api('api.detail')("%s.%s" % (self.sname, args['api'])))
        else:
            apilist = self.api('api.list')(self.sname)
            if not apilist:
                tmsg.append('nothing in the api')
            else:
                tmsg.extend(apilist)

        return True, tmsg

    def __afterload(self, args):  # pylint: disable=unused-argument
        """
    do something after the load function is run
    """
        # go through each variable and raise var_%s_changed
        self.settingvalues.raiseall()

        mud = self.api('managers.getm')('mud')

        if mud and mud.connected:
            if self.api('api.has')('connect.firstactive'):
                if self.api('connect.firstactive')():
                    self.afterfirstactive()
            else:
                self.api('events.register')('firstactive',
                                            self.afterfirstactive,
                                            prio=self.firstactiveprio)
        else:
            self.api('events.register')('firstactive',
                                        self.afterfirstactive,
                                        prio=self.firstactiveprio)

    def __disconnect(self, args=None):  # pylint: disable=unused-argument
        """
    re-register to firstactive on disconnect
    """
        self.api('send.msg')('baseplugin, disconnect')
        self.api('events.register')('firstactive', self.afterfirstactive)

    def afterfirstactive(self, args=None):  # pylint: disable=unused-argument
        """
    if we are connected do
    """
        self.api('send.msg')('baseplugin, firstactive')
        if self.api('events.isregistered')('firstactive',
                                           self.afterfirstactive):
            self.api('events.unregister')('firstactive', self.afterfirstactive)

    # get the vaule of a setting
    def _api_settinggets(self, setting):
        """  get the value of a setting
    @Ysetting@w = the setting value to get

    this function returns the value of the setting, None if not found"""
        try:
            return self.api('utils.verify')(self.settingvalues[setting],
                                            self.settings[setting]['stype'])
        except KeyError:
            return None

    # add a plugin dependency
    def _api_dependencyadd(self, dependency):
        """  add a depencency
    @Ydependency@w    = the name of the plugin that will be a dependency

    this function returns no values"""
        if dependency not in self.dependencies:
            self.dependencies.append(dependency)

    # change the value of a setting
    def _api_settingchange(self, setting, value):
        """  change a setting
    @Ysetting@w    = the name of the setting to change
    @Yvalue@w      = the value to set it as

    this function returns True if the value was changed, False otherwise"""
        if value == 'default':
            value = self.settings[setting]['default']
        if setting in self.settings:
            self.settingvalues[setting] = self.api('utils.verify')(
                value, self.settings[setting]['stype'])
            self.settingvalues.sync()
            return True

        return False

    def getstats(self):
        """
    get the stats for the plugin
    """
        stats = {}
        stats['Base Sizes'] = {}
        stats['Base Sizes']['showorder'] = ['Class', 'Variables', 'Api']
        stats['Base Sizes']['Variables'] = '%s bytes' % \
                                          sys.getsizeof(self.settingvalues)
        stats['Base Sizes']['Class'] = '%s bytes' % sys.getsizeof(self)
        stats['Base Sizes']['Api'] = '%s bytes' % sys.getsizeof(self.api)

        return stats

    def _cmd_stats(self, args=None):  # pylint: disable=unused-argument
        """
    @G%(name)s@w - @B%(cmdname)s@w
    show stats, memory, profile, etc.. for this plugin
    @CUsage@w: stats
    """
        stats = self.getstats()
        tmsg = []
        for header in stats:
            tmsg.append(self.api('utils.center')(header, '=', 60))
            for subtype in stats[header]['showorder']:
                tmsg.append('%-20s : %s' % (subtype, stats[header][subtype]))

        return True, tmsg

    def unload(self, _=None):
        """
    unload stuff
    """
        self.api('send.msg')('unloading %s' % self.name)

        # remove anything out of the api
        self.api('api.remove')(self.sname)

        #save the state
        self.savestate()

    def __savestate(self, _=None):
        """
    save the settings state
    """
        self.settingvalues.sync()

    def savestate(self, _=None):
        """
    save all settings for the plugin
    do not overload!

    attach to the plugin_<pluginname>_savestate event
    """
        self.api('events.eraise')('plugin_%s_savestate' % self.sname)

    def _cmd_set(self, args):
        """
    @G%(name)s@w - @B%(cmdname)s@w
    List or set vars
    @CUsage@w: var @Y<varname>@w @Y<varvalue>@w
      @Ysettingname@w    = The setting to set
      @Ysettingvalue@w   = The value to set it to
      if there are no arguments or 'list' is the first argument then
      it will list the settings for the plugin
    """
        msg = []
        if args['name'] == 'list':
            return True, self._listvars()
        elif args['name'] and args['value']:
            var = args['name']
            val = args['value']
            if var in self.settings:
                if 'readonly' in self.settings[var] \
                      and self.settings[var]['readonly']:
                    return True, ['%s is a readonly setting' % var]
                else:
                    try:
                        self.api('setting.change')(var, val)
                        tvar = self.settingvalues[var]
                        if self.settings[var]['nocolor']:
                            tvar = tvar.replace('@', '@@')
                        elif self.settings[var]['stype'] == 'color':
                            tvar = '%s%s@w' % (val, val.replace('@', '@@'))
                        elif self.settings[var]['stype'] == 'timelength':
                            tvar = self.api('utils.formattime')(
                                self.api('utils.verify')(val, 'timelength'))
                        return True, ['%s is now set to %s' % (var, tvar)]
                    except ValueError:
                        msg = ['Cannot convert %s to %s' % \
                                          (val, self.settings[var]['stype'])]
                        return True, msg
                return True, self._listvars()
            else:
                msg = ['plugin setting %s does not exist' % var]
        return False, msg

    def _cmd_save(self, args):  # pylint: disable=unused-argument
        """
    @G%(name)s@w - @B%(cmdname)s@w
    save plugin state
    @CUsage@w: save
    """
        self.savestate()
        return True, ['Plugin settings saved']

    def _cmd_help(self, args):
        """
    test command
    """
        msg = []

        if '.__init__' in self.fullimploc:
            imploc = self.fullimploc.replace('.__init__', '')
        else:
            imploc = self.fullimploc

        msg.extend(sys.modules[imploc].__doc__.split('\n'))
        if args['commands']:
            cmdlist = self.api('commands.list')(self.sname)
            if cmdlist:
                msg.extend(self.api('commands.list')(self.sname))
                msg.append('@G' + '-' * 60 + '@w')
                msg.append('')
        if args['api']:
            apilist = self.api('api.list')(self.sname)
            if apilist:
                msg.append('API functions in %s' % self.sname)
                msg.append('@G' + '-' * 60 + '@w')
                msg.extend(self.api('api.list')(self.sname))
        return True, msg

    def _listvars(self):
        """
    return a list of strings that list all settings
    """
        tmsg = []
        if not self.settingvalues:
            tmsg.append('There are no settings defined')
        else:
            tform = '%-15s : %-15s - %s'
            for i in self.settings:
                val = self.settingvalues[i]
                if 'nocolor' in self.settings[i] and self.settings[i][
                        'nocolor']:
                    val = val.replace('@', '@@')
                elif self.settings[i]['stype'] == 'color':
                    val = '%s%s@w' % (val, val.replace('@', '@@'))
                elif self.settings[i]['stype'] == 'timelength':
                    val = self.api('utils.formattime')(
                        self.api('utils.verify')(val, 'timelength'))
                tmsg.append(tform % (i, val, self.settings[i]['help']))
        return tmsg

    # add a setting to the plugin
    def _api_settingadd(self, name, default, stype, shelp, **kwargs):
        """  remove a command
    @Yname@w     = the name of the setting
    @Ydefault@w  = the default value of the setting
    @Ystype@w    = the type of the setting
    @Yshelp@w    = the help associated with the setting
    Keyword Arguments
      @Ynocolor@w    = if True, don't parse colors when showing value
      @Yreadonly@w   = if True, can't be changed by a client

    this function returns no values"""

        if 'nocolor' in kwargs:
            nocolor = kwargs['nocolor']
        else:
            nocolor = False
        if 'readonly' in kwargs:
            readonly = kwargs['readonly']
        else:
            readonly = False
        if name not in self.settingvalues:
            self.settingvalues[name] = default
        self.settings[name] = {
            'default': default,
            'help': shelp,
            'stype': stype,
            'nocolor': nocolor,
            'readonly': readonly
        }

    def _cmd_reset(self, _=None):
        """
    @G%(name)s@w - @B%(cmdname)s@w
      reset the plugin
      @CUsage@w: reset
    """
        if self.canreset:
            self.reset()
            return True, ['Plugin reset']

        return True, ['This plugin cannot be reset']

    def ischangedondisk(self):
        """
    check to see if the file this plugin is based on has changed on disk
    """
        ftime = os.path.getmtime(self.pluginfile)
        if ftime > self.loadedtime:
            return True

        return False

    def reset(self):
        """
    internal function to reset data
    """
        if self.canreset:
            self.resetflag = True
            self.settingvalues.clear()
            for i in self.settings:
                self.settingvalues[i] = self.settings[i]['default']
            self.settingvalues.sync()
            self.resetflag = False

    # add a function to the api
    def _api_add(self, name, func):
        """
    add a command to the api
    """
        # we call the non overloaded versions
        self.api.add(self.sname, name, func)
Example #20
0
class BasePlugin(object):
  # pylint: disable=too-many-public-methods,too-many-instance-attributes
  """
  a base class for plugins
  """
  def __init__(self, name, sname, modpath, basepath, fullimploc):
    # pylint: disable=too-many-arguments
    """
    initialize the instance
    The following things should not be done in __init__ in a plugin
      Interacting with anything in the api except api.add, api.overload
          or dependency.add
    """
    self.author = ''
    self.purpose = ''
    self.version = 0
    self.priority = 100
    self.name = name
    self.sname = sname
    self.dependencies = []
    self.versionfuncs = {}
    self.reloaddependents = False
    self.canreload = True
    self.resetflag = True
    self.api = API()
    self.loadedtime = time.time()
    self.savedir = os.path.join(self.api.BASEPATH, 'data',
                                'plugins', self.sname)
    try:
      os.makedirs(self.savedir)
    except OSError:
      pass
    self.savefile = os.path.join(self.api.BASEPATH, 'data',
                                 'plugins', self.sname, 'settingvalues.txt')
    self.modpath = modpath
    self.basepath = basepath
    self.fullimploc = fullimploc
    self.pluginfile = os.path.join(basepath, modpath[1:])
    self.pluginlocation = os.path.normpath(
        os.path.join(self.api.BASEPATH, 'plugins') + \
          os.sep + os.path.dirname(self.modpath))

    self.package = fullimploc.split('.')[1]

    self.settings = {}
    self.settingvalues = PersistentDictEvent(self, self.savefile, 'c')

    self._dump_shallow_attrs = ['api']

    self.api.overload('dependency', 'add', self.api_dependencyadd)
    self.api.overload('setting', 'add', self.api_settingadd)
    self.api.overload('setting', 'gets', self.api_settinggets)
    self.api.overload('setting', 'change', self.api_settingchange)
    self.api.overload('api', 'add', self.api_add)

  def load(self):
    """
    load stuff, do most things here
    """
    self.settingvalues.pload()

    if '_version' in self.settingvalues and \
        self.settingvalues['_version'] != self.version:
      self.updateversion(self.settingvalues['_version'], self.version)

    self.api.get('log.adddtype')(self.sname)

    parser = argparse.ArgumentParser(
        add_help=False,
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description=textwrap.dedent("""
          change a setting in the plugin

          if there are no arguments or 'list' is the first argument then
          it will list the settings for the plugin"""))
    parser.add_argument('name',
                        help='the setting name',
                        default='list',
                        nargs='?')
    parser.add_argument('value',
                        help='the new value of the setting',
                        default='',
                        nargs='?')
    self.api.get('commands.add')('set',
                                 self.cmd_set,
                                 parser=parser,
                                 group='Base',
                                 history=False)

    parser = argparse.ArgumentParser(add_help=False,
                                     description='reset the plugin')
    self.api.get('commands.add')('reset',
                                 self.cmd_reset,
                                 parser=parser,
                                 group='Base')

    parser = argparse.ArgumentParser(add_help=False,
                                     description='save the plugin state')
    self.api.get('commands.add')('save',
                                 self.cmd_save,
                                 parser=parser,
                                 group='Base')

    parser = argparse.ArgumentParser(add_help=False,
                                     description='show plugin stats')
    self.api.get('commands.add')('stats',
                                 self.cmd_stats,
                                 parser=parser,
                                 group='Base')

    parser = argparse.ArgumentParser(add_help=False,
                                     description='inspect a plugin')
    parser.add_argument('-m',
                        "--method",
                        help="get code for a method",
                        default='')
    parser.add_argument('-o',
                        "--object",
                        help="show an object of the plugin, can be method or variable",
                        default='')
    parser.add_argument('-s',
                        "--simple",
                        help="show a simple output",
                        action="store_true")
    self.api.get('commands.add')('inspect',
                                 self.cmd_inspect,
                                 parser=parser,
                                 group='Base')

    parser = argparse.ArgumentParser(add_help=False,
                                     description='show help info for this plugin')
    parser.add_argument('-a',
                        "--api",
                        help="show functions this plugin has in the api",
                        action="store_true")
    parser.add_argument('-c',
                        "--commands",
                        help="show commands in this plugin",
                        action="store_true")
    self.api.get('commands.add')('help',
                                 self.cmd_help,
                                 parser=parser,
                                 group='Base')

    parser = argparse.ArgumentParser(add_help=False,
                                     description='list functions in the api')
    parser.add_argument('api',
                        help='api to get details of',
                        default='',
                        nargs='?')
    self.api.get('commands.add')('api',
                                 self.cmd_api,
                                 parser=parser,
                                 group='Base')

    self.api.get('events.register')('%s_plugin_loaded' % self.sname,
                                    self.afterload)

    self.api.get('events.register')('muddisconnect', self.disconnect)

    self.resetflag = False

  def updateversion(self, oldversion, newversion):
    """
    update plugin data
    """
    if oldversion != newversion and newversion > oldversion:
      for i in range(oldversion + 1, newversion + 1):
        self.api.get('send.msg')(
            '%s: upgrading to version %s' % (self.sname, i),
            secondary='upgrade')
        if i in self.versionfuncs:
          self.versionfuncs[i]()
        else:
          self.api.get('send.msg')(
              '%s: no function to upgrade to version %s' % (self.sname, i),
              secondary='upgrade')

    self.settingvalues.sync()

  def cmd_inspect(self, args):
    # pylint: disable=too-many-branches
    """
    show the plugin as it currently is in memory
    """
    from libs.objectdump import dumps as dumper

    tmsg = []
    if args['method']:
      try:
        tmeth = getattr(self, args['method'])
        tmsg.append(inspect.getsource(tmeth))
      except AttributeError:
        tmsg.append('There is no method named %s' % args['method'])

    elif args['object']:
      tobj = args['object']
      key = None
      if ':' in tobj:
        tobj, key = tobj.split(':')

      obj = getattr(self, tobj)
      if obj:
        if key:
          if key not in obj:
            try:
              key = int(key)
            except ValueError:
              pass
          if key in obj:
            obj = obj[key]
        if args['simple']:
          tvars = pprint.pformat(obj)
        else:
          tvars = dumper(obj)
        tmsg.append(tvars)

    else:
      if args['simple']:
        tvars = pprint.pformat(vars(self))
      else:
        tvars = dumper(self)

      tmsg.append('@M' + '-' * 60 + '@x')
      tmsg.append('Variables')
      tmsg.append('@M' + '-' * 60 + '@x')
      tmsg.append(tvars)
      tmsg.append('@M' + '-' * 60 + '@x')
      tmsg.append('Methods')
      tmsg.append('@M' + '-' * 60 + '@x')
      tmsg.append(pprint.pformat(inspect.getmembers(self, inspect.ismethod)))

    return True, tmsg

  def cmd_api(self, args):
    """
    list functions in the api for a plugin
    """
    tmsg = []
    if args['api']:
      tmsg.extend(self.api.get('api.detail')("%s.%s" % (self.sname,
                                                        args['api'])))
    else:
      apilist = self.api.get('api.list')(self.sname)
      if not apilist:
        tmsg.append('nothing in the api')
      else:
        tmsg.extend(apilist)

    return True, tmsg

  def afterload(self, args):
    # pylint: disable=unused-argument
    """
    do something after the load function is run
    """
    proxy = self.api.get('managers.getm')('proxy')

    if proxy and proxy.connected:
      if self.api.get('api.has')('connect.firstactive'):
        if self.api.get('connect.firstactive')():
          self.afterfirstactive()
      else:
        self.api.get('events.register')('firstactive', self.afterfirstactive)
    else:
      self.api.get('events.register')('firstactive', self.afterfirstactive)

  def disconnect(self, args=None):
    # pylint: disable=unused-argument
    """
    re-register to firstactive on disconnect
    """
    self.api.get('send.msg')('baseplugin, disconnect')
    self.api.get('events.register')('firstactive', self.afterfirstactive)

  # get the vaule of a setting
  def api_settinggets(self, setting):
    """  get the value of a setting
    @Ysetting@w = the setting value to get

    this function returns the value of the setting, None if not found"""
    try:
      return self.api.get('utils.verify')(self.settingvalues[setting],
                                          self.settings[setting]['stype'])
    except KeyError:
      return None

  # add a plugin dependency
  def api_dependencyadd(self, dependency):
    """  add a depencency
    @Ydependency@w    = the name of the plugin that will be a dependency

    this function returns no values"""
    if dependency not in self.dependencies:
      self.dependencies.append(dependency)

  # change the value of a setting
  def api_settingchange(self, setting, value):
    """  change a setting
    @Ysetting@w    = the name of the setting to change
    @Yvalue@w      = the value to set it as

    this function returns True if the value was changed, False otherwise"""
    if value == 'default':
      value = self.settings[setting]['default']
    if setting in self.settings:
      self.settingvalues[setting] = self.api.get('utils.verify')(
          value,
          self.settings[setting]['stype'])
      self.settingvalues.sync()
      return True

    return False

  def getstats(self):
    """
    get the stats for the plugin
    """
    stats = {}
    stats['Base Sizes'] = {}
    stats['Base Sizes']['showorder'] = ['Class', 'Variables', 'Api']
    stats['Base Sizes']['Variables'] = '%s bytes' % \
                                      sys.getsizeof(self.settingvalues)
    stats['Base Sizes']['Class'] = '%s bytes' % sys.getsizeof(self)
    stats['Base Sizes']['Api'] = '%s bytes' % sys.getsizeof(self.api)

    return stats

  def cmd_stats(self, args=None):
    # pylint: disable=unused-argument
    """
    @G%(name)s@w - @B%(cmdname)s@w
    show stats, memory, profile, etc.. for this plugin
    @CUsage@w: stats
    """
    stats = self.getstats()
    tmsg = []
    for header in stats:
      tmsg.append(self.api.get('utils.center')(header, '=', 60))
      for subtype in stats[header]['showorder']:
        tmsg.append('%-20s : %s' % (subtype, stats[header][subtype]))

    return True, tmsg

  def unload(self, _=None):
    """
    unload stuff
    """
    self.api.get('send.msg')('unloading %s' % self.name)

    # remove anything out of the api
    self.api.get('api.remove')(self.sname)

    #save the state
    self.savestate()

  def savestate(self):
    """
    save the state
    """
    self.settingvalues.sync()

  def cmd_set(self, args):
    """
    @G%(name)s@w - @B%(cmdname)s@w
    List or set vars
    @CUsage@w: var @Y<varname>@w @Y<varvalue>@w
      @Ysettingname@w    = The setting to set
      @Ysettingvalue@w   = The value to set it to
      if there are no arguments or 'list' is the first argument then
      it will list the settings for the plugin
    """
    msg = []
    if args['name'] == 'list':
      return True, self.listvars()
    elif args['name'] and args['value']:
      var = args['name']
      val = args['value']
      if var in self.settings:
        if 'readonly' in self.settings[var] \
              and self.settings[var]['readonly']:
          return True, ['%s is a readonly setting' % var]
        else:
          try:
            self.api.get('setting.change')(var, val)
            tvar = self.settingvalues[var]
            if self.settings[var]['nocolor']:
              tvar = tvar.replace('@', '@@')
            elif self.settings[var]['stype'] == 'color':
              tvar = '%s%s@w' % (val, val.replace('@', '@@'))
            elif self.settings[var]['stype'] == 'timelength':
              tvar = self.api.get('utils.formattime')(
                  self.api.get('utils.verify')(val, 'timelength'))
            return True, ['%s is now set to %s' % (var, tvar)]
          except ValueError:
            msg = ['Cannot convert %s to %s' % \
                              (val, self.settings[var]['stype'])]
            return True, msg
        return True, self.listvars()
      else:
        msg = ['plugin setting %s does not exist' % var]
    return False, msg

  def cmd_save(self, args):
    # pylint: disable=unused-argument
    """
    @G%(name)s@w - @B%(cmdname)s@w
    save plugin state
    @CUsage@w: save
    """
    self.savestate()
    return True, ['Plugin settings saved']

  def cmd_help(self, args):
    """
    test command
    """
    msg = []

    msg.extend(sys.modules[self.fullimploc].__doc__.split('\n'))
    if args['commands']:
      cmdlist = self.api.get('commands.list')(self.sname)
      if cmdlist:
        msg.extend(self.api.get('commands.list')(self.sname))
        msg.append('@G' + '-' * 60 + '@w')
        msg.append('')
    if args['api']:
      apilist = self.api.get('api.list')(self.sname)
      if apilist:
        msg.append('API functions in %s' % self.sname)
        msg.append('@G' + '-' * 60 + '@w')
        msg.extend(self.api.get('api.list')(self.sname))
    return True, msg

  def listvars(self):
    """
    return a list of strings that list all settings
    """
    tmsg = []
    if len(self.settingvalues) == 0:
      tmsg.append('There are no settings defined')
    else:
      tform = '%-15s : %-15s - %s'
      for i in self.settings:
        val = self.settingvalues[i]
        if 'nocolor' in self.settings[i] and self.settings[i]['nocolor']:
          val = val.replace('@', '@@')
        elif self.settings[i]['stype'] == 'color':
          val = '%s%s@w' % (val, val.replace('@', '@@'))
        elif self.settings[i]['stype'] == 'timelength':
          val = self.api.get('utils.formattime')(
              self.api.get('utils.verify')(val, 'timelength'))
        tmsg.append(tform % (i, val, self.settings[i]['help']))
    return tmsg

  # add a setting to the plugin
  def api_settingadd(self, name, default, stype, shelp, **kwargs):
    """  remove a command
    @Yname@w     = the name of the setting
    @Ydefault@w  = the default value of the setting
    @Ystype@w    = the type of the setting
    @Yshelp@w    = the help associated with the setting
    Keyword Arguments
      @Ynocolor@w    = if True, don't parse colors when showing value
      @Yreadonly@w   = if True, can't be changed by a client

    this function returns no values"""

    if 'nocolor' in kwargs:
      nocolor = kwargs['nocolor']
    else:
      nocolor = False
    if 'readonly' in kwargs:
      readonly = kwargs['readonly']
    else:
      readonly = False
    if name not in self.settingvalues:
      self.settingvalues[name] = default
    self.settings[name] = {
        'default':default,
        'help':shelp,
        'stype':stype,
        'nocolor':nocolor,
        'readonly':readonly
    }

  def cmd_reset(self, _=None):
    """
    @G%(name)s@w - @B%(cmdname)s@w
      reset the plugin
      @CUsage@w: reset
    """
    self.reset()
    return True, ['Plugin reset']

  def ischangedondisk(self):
    """
    check to see if the file this plugin is based on has changed on disk
    """
    ftime = os.path.getmtime(self.pluginfile)
    if ftime > self.loadedtime:
      return True

    return False

  def reset(self):
    """
    internal function to reset data
    """
    self.resetflag = True
    self.settingvalues.clear()
    for i in self.settings:
      self.settingvalues[i] = self.settings[i]['default']
    self.settingvalues.sync()
    self.resetflag = False

  def afterfirstactive(self, _=None):
    """
    if we are connected do
    """
    self.api.get('send.msg')('baseplugin, firstactive')
    self.api.get('events.unregister')('firstactive', self.afterfirstactive)

  # add a function to the api
  def api_add(self, name, func):
    """
    add a command to the api
    """
    # we call the non overloaded versions
    self.api.add(self.sname, name, func)
Example #21
0
"""
handle output and input functions, adds items under the send api
"""
import time
import sys
import traceback
import re
from libs.api import API as BASEAPI

API = BASEAPI()

# send a message
def api_msg(tmsg, primary='default', secondary=None):
  """  send a message through the log plugin
    @Ymsg@w        = This message to send
    @Yprimary@w    = the primary datatype of the message (default: 'default')
    @Ysecondary@w  = the secondary datatype of the message
                        (default: 'None')

  this function returns no values"""
  if primary == 'default':
    try:
      primary = API('utils.funccallerplugin')() or primary
    except (AttributeError, RuntimeError):
      pass

  if not isinstance(secondary, list):
    tmpl = []
    if secondary:
      tmpl.append(secondary)
    secondary = tmpl