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()