def setup(self): self.logger.trace("Entered setup method.") self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/inter.yml") except Exception: self.logger.exception("Error loading configuration!") self.logger.error(_("Disabling..")) self._disable_self() return if not self.config.exists: self.logger.error("Unable to find config/plugins/inter.yml") self.logger.error(_("Disabling..")) self._disable_self() return self.config.add_callback(self.reload) self.commands.register_command("players", self.players_command, self, "inter.players", default=True) if not reactor.running: self.events.add_callback( "ReactorStarted", self, self.first_load, 0 ) else: self.first_load()
def setup(self): self.logger.trace("Entered setup method.") self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/feeds.yml") except Exception: self.logger.exception("Error loading configuration!") self.logger.error("Disabling..") self._disable_self() return if not self.config.exists: self.logger.error("Unable to find config/plugins/feeds.yml") self.logger.error("Disabling..") self._disable_self() return self.config.add_callback(self.delayed_setup) self.events = EventManager() self.plugman = PluginManager() self.logger.info("Waiting 30 seconds to set up.") reactor.callLater(30, self.delayed_setup)
def setup(self): ### Grab important shit self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() ### Initial config load try: self._config = self.storage.get_file(self, "config", YAML, "plugins/triggers.yml") except Exception: self.logger.exception("Error loading configuration!") self.logger.error("Disabling...") self._disable_self() return if not self._config.exists: self.logger.error("Unable to find config/plugins/triggers.yml") self.logger.error("Disabling...") self._disable_self() return ### Register event handlers def _message_event_filter(event=MessageReceived): return isinstance(event.target, Channel) self.events.add_callback("MessageReceived", self, self.message_handler, 1, _message_event_filter) self.events.add_callback("ActionReceived", self, self.action_handler, 1, _message_event_filter)
def setup(self): self.events = EventManager() self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/blowfish.yml") except Exception: self.logger.exception("Error loading configuration!") self._disable_self() return if not self.config.exists: self.logger.error("Unable to find config/plugins/blowfish.yml") self._disable_self() return self.events.add_callback("PreMessageReceived", self, self.pre_message, 10001) self.events.add_callback("MessageSent", self, self.message_sent, 10001) self.events.add_callback("ActionReceived", self, self.message_sent, 10001) self.events.add_callback("ActionSent", self, self.message_sent, 10001)
def __init__(self): self.commands = CommandManager() self.event_manager = EventManager() self.logger = getLogger("Manager") self.plugman = PluginManager(self) self.yapsy_logger = getLogger("yapsy") self.metrics = None
def setup(self): # Define this so we have instances of everything we need self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() self.plugman = PluginManager() # Now run the actual setup function self.wrapper(self.clj_plugin.setup)()
def setup(self): """ Called when the plugin is loaded. Performs initial setup. """ self.logger.trace(_("Entered setup method.")) self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/urls.yml") except Exception: self.logger.exception(_("Error loading configuration!")) else: if not self.config.exists: self.logger.warn(_("Unable to find config/plugins/urls.yml")) else: self.content_types = self.config["content_types"] self.spoofing = self.config["spoofing"] self.logger.debug(_("Spoofing: %s") % self.spoofing) self.channels = self.storage.get_file(self, "data", YAML, "plugins/urls/channels.yml") self.shortened = self.storage.get_file( self, "data", DBAPI, "sqlite3:data/plugins/urls/shortened.sqlite", "data/plugins/urls/shortened.sqlite", check_same_thread=False) self.commands = CommandManager() self.events = EventManager() self.reload() def message_event_filter(event=MessageReceived): target = event.target type_ = event.type return type_ == "message" \ or isinstance(target, Channel) \ or isinstance(target, User) self.add_shortener("tinyurl", self.tinyurl) self.events.add_callback("MessageReceived", self, self.message_handler, 1, message_event_filter) self.commands.register_command("urls", self.urls_command, self, "urls.manage") self.commands.register_command("shorten", self.shorten_command, self, "urls.shorten", default=True)
def __init__(self, name, factory, config): NoChannelsProtocol.__init__(self, name, factory, config) self.name = name self.log = getLogger(self.name) self.event_manager = EventManager() self.command_manager = CommandManager() reactor.connectTCP(self.config["connection"]["host"], self.config["connection"]["port"], self.factory, 120)
def setup(self): # ## Grab important shit self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() self.plugman = PluginManager() # ## Set up database self.database = self.storage.get_file( self, "data", DBAPI, "sqlite3:data/plugins/factoids.sqlite", "data/plugins/factoids.sqlite", check_same_thread=False ) self.database.add_callback(self.reload) self.reload() # ## Register commands # We have multiple possible permissions per command, so we have to do # permission handling ourselves self.commands.register_command("addfactoid", self.factoid_add_command, self, None) self.commands.register_command("setfactoid", self.factoid_set_command, self, None) self.commands.register_command("deletefactoid", self.factoid_delete_command, self, None, ["delfactoid"]) self.commands.register_command("getfactoid", self.factoid_get_command, self, None, default=True) # ## Register events self.events.add_callback("MessageReceived", self, self.message_handler, 1) self.events.add_callback("Web/ServerStartedEvent", self, self.web_routes, 1)
def setup(self): self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() # self.data = self.storage.get_file(self, "data", SQLITE, # "plugins/memos/memos.sqlite") # with self.data as c: # # Multiline strings because of an IDE bug # c.execute("""CREATE TABLE IF NOT EXISTS memos # (to TEXT, from TEXT, memo TEXT)""") self.events.add_callback("PreMessageReceived", self, self.message_received, 0) self.commands.register_command("memo", self.memo_command, self, "memo.send", default=True)
def setup(self): """The list of bridging rules""" self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() self.data = self.storage.get_file(self, "data", YAML, "plugins/dialectizer/settings.yml") self.events.add_callback("MessageSent", self, self.handle_msg_sent, 1) self.commands.register_command("dialectizer", self.dialectizer_command, self, "dialectizer.set", aliases=["dialectiser"])
def __init__(self, name, factory, config): self.name = name self.factory = factory self.config = config self.received = "" self.log = getLogger(self.name) self.log.info("Setting up..") self.command_manager = CommandManager() self.event_manager = EventManager() self.username = config["identity"]["username"] self.password = config["identity"]["password"] self.networking = config["network"] self.tokens = config["identity"]["tokens"] self.control_chars = config["control_chars"] audio_conf = config.get("audio", {}) self.should_mute_self = audio_conf.get("should_mute_self", True) self.should_deafen_self = audio_conf.get("should_deafen_self", True) event = general_events.PreConnectEvent(self, config) self.event_manager.run_callback("PreConnect", event) context = self._get_client_context() if context is None: # Could not create a context (problem loading cert file) self.factory.manager.remove_protocol(self.name) return reactor.connectSSL( self.networking["address"], self.networking["port"], self.factory, context, 120 ) event = general_events.PostConnectEvent(self, config) self.event_manager.run_callback("PostConnect", event)
def setup(self): ### Grab important shit self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() ### Initial config load try: self.config = self.storage.get_file(self, "config", YAML, "plugins/drunkoctopus.yml") except Exception: self.logger.exception("Error loading configuration!") self.logger.error("Disabling...") self._disable_self() return if not self.config.exists: self.logger.error("Unable to find config/plugins/drunkoctopus.yml") self.logger.error("Disabling...") self._disable_self() return ### Create vars and stuff self._sobering_call = None self._drunktalk = DrunkTalk() ### Load options from config self._load() self.config.add_callback(self._load) ### Register events and commands self.events.add_callback("MessageSent", self, self.outgoing_message_handler, 1) self.commands.register_command("drunkenness", self.drunkenness_command, self, "drunkoctopus.drunkenness", default=True) self.commands.register_command("drink", self.drink_command, self, "drunkoctopus.drink")
def setup(self): self.logger.trace("Entered setup method.") self.commands = CommandManager() self.events = EventManager() self.plugins = PluginManager() self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/twilio.yml") except Exception: self.logger.exception("Error loading configuration!") return self._disable_self() else: if not self.config.exists: self.logger.error("Unable to find config/plugins/twilio.yml") return self._disable_self() try: self.data = self.storage.get_file(self, "data", JSON, "plugins/twilio/contacts.json") except Exception: self.logger.exception("Error loading data!") self.logger.error("This data file is required. Shutting down...") return self._disable_self() self._load() self.config.add_callback(self._load) self.events.add_callback("Web/ServerStartedEvent", self, self.add_routes, 0) self.commands.register_command("sms", self.sms_command, self, "twilio.sms") self.commands.register_command("mms", self.mms_command, self, "twilio.mms") self.commands.register_command("tw", self.tw_command, self, "twilio.tw")
def setup(self): self.logger.trace("Entered setup method.") self.commands = CommandManager() self.events = EventManager() self.plugins = PluginManager() self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/webhooks.yml") except Exception: self.logger.exception("Error loading configuration!") return self._disable_self() else: if not self.config.exists: self.logger.error("Unable to find config/plugins/webhooks.yml") return self._disable_self() self._load() self.config.add_callback(self._load) self.events.add_callback("Web/ServerStartedEvent", self, self.add_routes, 0)
def setup(self): self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/web.yml") self.logger.debug("Config loaded") except Exception: self.logger.exception(_("Error loading configuration")) self._disable_self() return if not self.config.exists: self.logger.error(_("Unable to find config/plugins/web.yml")) self._disable_self() return try: self.data = self.storage.get_file(self, "data", JSON, "plugins/web/data.json") self.logger.debug("Data loaded") except Exception: self.logger.exception("Error loading data file!") return self._disable_self() try: _sessions = self.storage.get_file(self, "data", JSON, "plugins/web/sessions.json") self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading sessions file!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() try: self.api_key_data = self.storage.get_file( self, "data", JSON, "plugins/web/apikeys.json" ) self.logger.debug("Sessions loaded") except Exception: self.logger.exception("Error loading API keys!") return self._disable_self() try: self.api_log = open("logs/api.log", "w") except Exception: self.logger.exception("Unable to open api log file!") return self._disable_self() self.config.add_callback(self.restart) self.data.add_callback(self.restart) # Index page self.add_handler(r"/", "plugins.web.routes.index.Route") # Login-related self.add_handler(r"/login", "plugins.web.routes.login.Route") self.add_handler(r"/logout", "plugins.web.routes.logout.Route") self.add_handler( r"/login/reset", "plugins.web.routes.login-reset.Route" ) # Accounts-related self.add_handler(r"/account", "plugins.web.routes.account.index.Route") self.add_handler( r"/account/password/change", "plugins.web.routes.account.password.change.Route" ) self.add_handler( r"/account/apikeys/create", "plugins.web.routes.account.apikeys.create.Route" ) self.add_handler( r"/account/apikeys/delete", "plugins.web.routes.account.apikeys.delete.Route" ) self.add_handler( r"/account/users/logout", "plugins.web.routes.account.users.logout.Route" ) # Admin-related self.add_handler( r"/admin", "plugins.web.routes.admin.index.Route" ) self.add_handler( r"/admin/files", "plugins.web.routes.admin.files.Route" ) self.add_handler( r"/admin/files/(config|data)/(.*)", "plugins.web.routes.admin.file.Route" ) self.add_handler( r"/api/admin/get_stats", "plugins.web.routes.api.admin.get_stats.Route" ) self.add_navbar_entry("admin", "/admin", "settings") # API routes self.add_api_handler( r"/plugins/web/get_username", "plugins.web.routes.api.plugins.web.get_username.Route" ) # Stuff routes might find useful self.api_keys = APIKeys(self, self.api_key_data) self.commands = CommandManager() self.events = EventManager() self.packages = Packages(False) self.plugins = PluginManager() self.sessions = Sessions(self, _sessions) self.stats = Stats() # Load 'er up! r = self.load() if not r: self._disable_self() return if not self.factory_manager.running: self.events.add_callback( "ReactorStarted", self, self.start, 0 ) else: self.start()
__author__ = 'Gareth Coles' import os import sys print os.getcwd() sys.path.append(os.getcwd()) # Because herp derp import cProfile from profiling.fakes import FakePlugin, FakePluginEvent from system.event_manager import EventManager events = EventManager() class EventPlugin(FakePlugin): def __init__(self, info): super(EventPlugin, self).__init__(info) events.add_callback("Test", self, self.event_callback, 0) def event_callback(self, event): pass def do_profile(): plugin = EventPlugin({"name": "FAAAAAAAAKE!"}) cProfile.run("run()")
def setup(self): """ Called when the plugin is loaded. Performs initial setup. """ reload(auth_handler) reload(permissions_handler) self.logger.trace(_("Entered setup method.")) self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/auth.yml") except Exception: self.logger.exception(_("Error loading configuration!")) self.logger.error(_("Disabling..")) self._disable_self() return if not self.config.exists: self.logger.error(_("Unable to find config/plugins/auth.yml")) self.logger.error(_("Disabling..")) self._disable_self() return self.commands = CommandManager() self.events = EventManager() if self.config["use-permissions"]: try: self.permissions = self.storage.get_file( self, "data", YAML, "plugins/auth/" # PEP "permissions.yml") except Exception: self.logger.exception( _("Unable to load permissions. They " "will be unavailable!")) else: self.perms_h = permissions_handler.permissionsHandler( self, self.permissions) result = self.commands.set_permissions_handler(self.perms_h) if not result: self.logger.warn(_("Unable to set permissions handler!")) if self.config["use-auth"]: try: self.passwords = self.storage.get_file( self, "data", YAML, "plugins/auth/" # PEP! "passwords.yml") self.blacklist = self.storage.get_file( self, "data", YAML, "plugins/auth/" # PEP! "blacklist.yml") except Exception: self.logger.exception( _("Unable to load user accounts. They " "will be unavailable!")) else: self.auth_h = auth_handler.authHandler(self, self.passwords, self.blacklist) result = self.commands.set_auth_handler(self.auth_h) if not result: self.logger.warn(_("Unable to set auth handler!")) self.logger.debug(_("Registering commands.")) self.commands.register_command("login", self.login_command, self, "auth.login", default=True) self.commands.register_command("logout", self.logout_command, self, "auth.login", default=True) self.commands.register_command("register", self.register_command, self, "auth.register", default=True) self.commands.register_command("passwd", self.passwd_command, self, "auth.passwd", default=True) self.events.add_callback("PreCommand", self, self.pre_command, 10000)
def setup(self): self.commands = CommandManager() self.events = EventManager() self.storage = StorageManager() self.data = self.storage.get_file( self, "data", DBAPI, "sqlite3:data/plugins/lastseen/users.sqlite", "data/plugins/lastseen/users.sqlite", check_same_thread=False) self.data.runQuery("CREATE TABLE IF NOT EXISTS users (" "user TEXT, " "protocol TEXT, " "at INTEGER)") self.commands.register_command("seen", self.seen_command, self, "seen.seen", default=True) # General events self.events.add_callback("PreMessageReceived", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_source_caller]) self.events.add_callback("PreCommand", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_source_caller]) self.events.add_callback("NameChanged", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("UserDisconnected", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) # Mumble events self.events.add_callback("Mumble/UserRemove", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("Mumble/UserJoined", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("Mumble/UserMoved", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("Mumble/UserSelfMuteToggle", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("Mumble/UserSelfDeafToggle", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller]) self.events.add_callback("Mumble/UserRecordingToggle", self, self.event_handler, 0, cancelled=True, extra_args=[self.event_user_caller])
def setup(self): self.events = EventManager() self.regex = re.compile(r"(\w+)-ass (\w+)") self.events.add_callback("MessageReceived", self, self.ass_swap, 1)
def setup(self): """ Called when the plugin is loaded. Performs initial setup. """ self.logger.trace(_("Entered setup method.")) self.storage = StorageManager() try: self.config = self.storage.get_file(self, "config", YAML, "plugins/bridge.yml") except Exception: self.logger.exception(_("Error loading configuration!")) self.logger.error(_("Disabling..")) self._disable_self() return if not self.config.exists: self.logger.error(_("Unable to find config/plugins/bridge.yml")) self.logger.error(_("Disabling..")) self._disable_self() return self.commands = CommandManager() self.events = EventManager() # General self.events.add_callback("PreMessageReceived", self, self.handle_msg, 1000) self.events.add_callback("MessageSent", self, self.handle_msg_sent, 0) # self.events.add_callback("PreCommand", self, self.handle_command, # 1000) self.events.add_callback("ActionSent", self, self.handle_action_sent, 0) self.events.add_callback("UserDisconnected", self, self.handle_disconnect, 1000) # IRC self.events.add_callback("IRC/UserJoined", self, self.handle_irc_join, 1000) self.events.add_callback("IRC/UserParted", self, self.handle_irc_part, 1000) self.events.add_callback("IRC/UserKicked", self, self.handle_irc_kick, 1000) self.events.add_callback("IRC/UserQuit", self, self.handle_irc_quit, 1000) self.events.add_callback("IRC/CTCPQueryReceived", self, self.handle_irc_action, 1000) # Mumble self.events.add_callback("Mumble/UserRemove", self, self.handle_mumble_remove, 1000) self.events.add_callback("Mumble/UserJoined", self, self.handle_mumble_join, 1000) self.events.add_callback("Mumble/UserMoved", self, self.handle_mumble_move, 1000)
def __init__(self, config=None, manager=None): if config is None or manager is None: raise ValueError("Config and manager must not be None!") self.config = config self.manager = manager self.log = getLogger("Metrics") self.storage = StorageManager() self.events = EventManager() self.packages = Packages(get=False) self.data = self.storage.get_file(self, "data", JSON, "metrics.json") self.task = LoopingCall(self.submit_metrics) if "metrics" in config: self.status = config["metrics"] if self.status == "on": self.status = True elif self.status == "off": self.status = False else: self.log.warn("\n%s\n" % warning) self.log.warn( _("We couldn't find a \"metrics\" option in your settings.yml" " file!")) self.log.warn( _("Metrics will default to being turned on. If this is not what" " you want, please create a \"metrics\" option in your " "settings and set it to \"off\".")) self.log.warn( _("If you want to keep metrics enabled, set the option to" " \"on\".")) self.log.warn( _("This warning will be shown on every startup until the option" " has been set.")) self.status = True if "send-exceptions" not in config: self.log.warn( _("We couldn't find a \"send-exceptions\" option in your " "settings.yml file!")) self.log.warn( _("Exception sending will default to being turned on. If this " "is not what you want, please create a \"send-exceptions\" " "option in your settings and set it to \"off\".")) self.log.warn( _("If you want to keep exception sending enabled, set the " "option to \"on\".")) self.log.warn( _("This warning will be shown on every startup until the option" " has been set.")) self.send_exceptions = config.get("send-exceptions", True) with self.data: if self.status is True: if "uuid" not in self.data: try: uuid = self.get(self.uuid_url) except Exception: self.log.exception(_("Error getting UUID")) return self.data["uuid"] = uuid self.data["status"] = "enabled" elif "uuid" not in self.data: self.data["status"] = "disabled" if self.status is False: if self.data["status"] == "disabled": self.log.info(_("Metrics are disabled.")) return elif self.status is "destroy": if "uuid" not in self.data: self.log.info(_("Metrics are disabled.")) return self.task.start(self.interval)
def __init__(self): self.logger = getLogger("Commands") self.event_manager = EventManager()