def __init__(self, config, args):
self.config = config
self.args = args
self.private_loop = asyncio.get_event_loop()
self.private_loop.set_exception_handler(custom_exception_handler)
self.discord_token = self.config["main"]["discord_token"]
ScheduleManager.init(self.private_loop)
DBManager.init(self.config["main"]["db"])
ActionParser.bot = self
# redis
redis_options = {}
if "redis" in config:
redis_options = dict(config.items("redis"))
RedisManager.init(**redis_options)
utils.wait_for_redis_data_loaded(RedisManager.get())
# SQL migrations
try:
with DBManager.create_dbapi_connection_scope() as sql_conn:
sql_migratable = DatabaseMigratable(sql_conn)
sql_migration = Migration(sql_migratable,
greenbot.migration_revisions.db,
self)
sql_migration.run()
except ValueError as error:
log.error(error)
HandlerManager.init_handlers()
self.movienight_api = MovieNightAPI(self, self.config["wsc"],
self.config["wowza_cdn"])
HandlerManager.add_handler("parse_command_from_message",
self.parse_command_from_message)
self.bot_name = self.config["main"]["bot_name"]
self.command_prefix = self.config["discord"]["command_prefix"]
self.settings = {
"discord_token": self.discord_token,
"bot_name": self.bot_name,
"command_prefix": self.command_prefix,
"discord_guild_id": self.config["discord"]["discord_guild_id"],
}
HandlerManager.add_handler("discord_ready", self.wait_discord_load)
self.discord_bot = DiscordBotManager(
bot=self,
settings=self.settings,
redis=RedisManager.get(),
private_loop=self.private_loop,
)
self.twitter_manager = TwitterManager(self)
self.filters = Filters(self, self.discord_bot)
self.functions = Functions(self, self.filters)
def init(args):
import subprocess
import sys
from flask import request
from flask import session
from flask_scrypt import generate_random_salt
import greenbot.utils
import greenbot.web.common
import greenbot.web.routes
from greenbot.managers.db import DBManager
from greenbot.managers.redis import RedisManager
from greenbot.managers.schedule import ScheduleManager
from greenbot.models.module import ModuleManager
from greenbot.models.sock import SocketClientManager
from greenbot.utils import load_config
from greenbot.web.models import errors
from greenbot.bothelper import BotHelper
ScheduleManager.init()
config = load_config(args.config)
redis_options = {}
if "redis" in config:
redis_options = dict(config["redis"])
RedisManager.init(**redis_options)
if "web" not in config:
log.error("Missing [web] section in config.ini")
sys.exit(1)
if "secret_key" not in config["web"]:
salt = generate_random_salt()
config.set("web", "secret_key", salt.decode("utf-8"))
with open(args.config, "w") as configfile:
config.write(configfile)
bot_name = config["main"]["bot_name"]
BotHelper.set_bot_name(bot_name)
SocketClientManager.init(bot_name)
app.bot_modules = config["web"].get("modules", "").split()
app.bot_commands_list = []
app.bot_config = config
app.secret_key = config["web"]["secret_key"]
app.config["DISCORD_CLIENT_ID"] = app.bot_config["discord"]["client_id"]
app.config["DISCORD_CLIENT_SECRET"] = app.bot_config["discord"][
"client_secret"]
app.config["DISCORD_REDIRECT_URI"] = app.bot_config["discord"][
"redirect_uri"]
app.bot_dev = ("flags" in config and "dev" in config["flags"]
and config["flags"]["dev"] == "1")
DBManager.init(config["main"]["db"])
app.module_manager = ModuleManager(None).load()
greenbot.web.routes.admin.init(app)
greenbot.web.routes.api.init(app)
greenbot.web.routes.base.init(app)
greenbot.web.common.filters.init(app)
greenbot.web.common.assets.init(app)
greenbot.web.common.menu.init(app)
errors.init(app, config)
last_commit = None
if app.bot_dev:
try:
last_commit = (subprocess.check_output(
["git", "log", "-1", "--format=%cd"]).decode("utf8").strip())
except:
log.exception(
"Failed to get last_commit, will not show last commit")
default_variables = {
"last_commit": last_commit,
"version": "v1.0",
"bot": {
"name": config["main"]["bot_name"]
},
"site": {
"domain": config["web"]["domain"]
},
"modules": app.bot_modules,
"request": request,
"session": session,
"google_analytics": config["web"].get("google_analytics", None),
}
@app.context_processor
def current_time():
current_time = {}
current_time["current_time"] = greenbot.utils.now()
return current_time
@app.context_processor
def inject_default_variables():
return default_variables