def init_api():
config.load_config()
logging.config.dictConfig(config.config["logging"])
CORS(app) # TODO: Holdover from node server, this may not be needed.
blueprint = Blueprint("api", __name__)
firebase_app = firebase_admin.initialize_app(credentials.Certificate(
config.config["auth"]["key-file"]),
options=config.config["auth"])
# Set up API and register namespaces
api = Api(
blueprint,
title="Beecology API",
description=
"The Beecology API, for uploading/downloading Beecology data or performing data analyses",
contact_email="*****@*****.**",
version="1.1.0",
default_mediatype="application/json",
authorizations=bee_authorizations,
validate=True)
api.add_namespace(bee_data_api.api)
api.add_namespace(analysis_api.api, "/analysis")
app.register_blueprint(blueprint)
def load_config():
logging.config.fileConfig(os.path.dirname(path.abspath(__file__)) + '/proof.ini')
logger.info('Loading config options.')
config = Configuration(os.path.dirname(path.abspath(__file__)) + '/proof.ini')
config.load_config()
logger.info('Config is loaded.')
return config
def set_config(cfg):
"""
Defines the configuration object
"""
global config
config=cfg
config.load_config()
# Defines the log configuration
logging.config.fileConfig(os.sep.join(
[os.path.dirname(config.CONFIG_FILE),'log.cfg']))
# Set the log level for sqlalchemy orm
logging.getLogger('sqlalchemy').setLevel(
eval('logging.'+config.get('database.log.level'))
)
def main():
if len(sys.argv) < 2:
log.info("Please specify the config file. Use default")
path = 'tweetstack.conf'
else:
path = sys.argv[1]
conf = config.load_config(path)
serv = service.Service(conf)
serv.run()
def print_versions(args):
"""Print versions and exit."""
versions = _("EH Forwarder Bot\n"
"Version: {version}\n"
"Python version:\n"
"{py_version}\n"
"Running on profile \"{profile}\".").format(
version=__version__,
py_version=sys.version,
profile=args.profile)
try:
if args.profile:
coordinator.profile = str(args.profile)
conf = config.load_config()
# Master channel
master_channel: MasterChannel = utils.locate_module(
conf['master_channel'], 'master')
instance_id = conf['master_channel'].split('#', 1)[1:]
instance_id = (instance_id and instance_id[0]) or _("Default instance")
versions += "\n\n" + _("Master channel:") + "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=master_channel.channel_name,
id=master_channel.channel_id,
version=master_channel.__version__,
instance_id=instance_id)
versions += "\n\n" + ngettext("Slave channel:", "Slave channels:",
len(conf['slave_channels']))
for i in conf['slave_channels']:
instance_id = i.split('#', 1)[1:]
instance_id = (instance_id
and instance_id[0]) or _("Default instance")
slave_channel: SlaveChannel = utils.locate_module(i, 'slave')
versions += "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=slave_channel.channel_name,
id=slave_channel.channel_id,
version=slave_channel.__version__,
instance_id=instance_id)
versions += "\n\n" + ngettext("Middleware:", "Middlewares:",
len(conf['middlewares']))
if conf['middlewares']:
for i in conf['middlewares']:
instance_id = i.split('#', 1)[1:]
instance_id = (instance_id
and instance_id[0]) or _("Default instance")
middleware: Middleware = utils.locate_module(i, 'middleware')
versions += "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=middleware.middleware_name,
id=middleware.middleware_id,
version=middleware.__version__,
instance_id=instance_id)
else:
versions += "\n " + _("No middleware is enabled.")
finally:
print(versions)
def __init__(self):
# Logging.
self.__setup_log()
self.logger.info('Starting game')
try:
# Data.
self.data = data.Data()
self.data.config.config_dir = self.CONFIG_DIR
# Load configuration.
config.load_config(self.data, self.CONFIG_DIR, self.CONFIG_LOAD_FILE)
# Draw decision trees.
if self.data.config.render_decision_trees:
renderer = dtr.DecisionTreeRenderer(self.DECISION_GRAPH_DIR, self.DECISION_GRAPH_FILE)
renderer.render(self.data.game.decision_tree.start_nodes, self.data.game.decision_tree.nodes)
# Demo mode.
demo_loader = demo.Demo(self.data)
demo_loader.load()
# State modules.
self.state_modules = [
demo_loader,
eventhandler.PygameEventHandler(self.data),
director.Director()
]
# Render modules.
self.render_modules = [
graphics.PygameGraphics(self.data),
cleaner.RenderCleaner()
]
# Initialize main loop.
super().__init__(1.0 / self.data.config.fps, self.data.config.max_frame_time)
except:
self.logger.exception(self.LOG_TEXT_EXCEPTION)
raise
def main():
args = parser.parse_args()
if getattr(args, "version", None):
return print_versions(args)
if args.profile:
coordinator.profile = str(args.profile)
conf = config.load_config()
setup_logging(args, conf)
setup_telemetry(conf['telemetry'])
atexit.register(stop_gracefully)
signal.signal(signal.SIGTERM, stop_gracefully)
signal.signal(signal.SIGINT, stop_gracefully)
init(conf)
poll()
def main():
args = parser.parse_args()
if getattr(args, "version", None):
return print_versions(args)
if args.trace_threads:
try:
import hanging_threads
global trace_threads
trace_threads = True
except ModuleNotFoundError:
print(
_("Required dependencies are not found. Please install them with "
"the following command:"))
print()
print(
f" ${sys.executable} -m pip install 'ehforwarderbot[trace]'"
)
print()
exit(1)
if args.profile:
coordinator.profile = str(args.profile)
conf = config.load_config()
setup_logging(args, conf)
setup_telemetry(conf['telemetry'])
init(conf)
# Only register graceful stop signals when we are ready to start
# polling threads.
atexit.register(stop_gracefully)
signal.signal(signal.SIGTERM, stop_gracefully)
signal.signal(signal.SIGINT, stop_gracefully)
poll()
def main():
args = parser.parse_args()
if getattr(args, "version", None):
versions = _("EH Forwarder Bot\n"
"Version: {version}\n"
"Python version:\n"
"{py_version}").format(version=__version__,
py_version=sys.version)
try:
conf = config.load_config()
# Master channel
master_channel: EFBChannel = utils.locate_module(
conf['master_channel'], 'master')
instance_id = conf['master_channel'].split('#', 1)[1:]
instance_id = (instance_id
and instance_id[0]) or _("Default instance")
versions += "\n\n" + _("Master channel:") + "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=master_channel.channel_name,
id=master_channel.channel_id,
version=master_channel.__version__,
instance_id=instance_id)
versions += "\n\n" + ngettext("Slave channel:", "Slave channels:",
len(conf['slave_channels']))
for i in conf['slave_channels']:
instance_id = i.split('#', 1)[1:]
instance_id = (instance_id
and instance_id[0]) or _("Default instance")
slave_channel: EFBChannel = utils.locate_module(i, 'slave')
versions += "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=slave_channel.channel_name,
id=slave_channel.channel_id,
version=slave_channel.__version__,
instance_id=instance_id)
versions += "\n\n" + ngettext("Middleware:", "Middlewares:",
len(conf['middlewares']))
if conf['middlewares']:
for i in conf['middlewares']:
instance_id = i.split('#', 1)[1:]
instance_id = (instance_id
and instance_id[0]) or _("Default instance")
middleware: EFBMiddleware = utils.locate_module(
i, 'middleware')
versions += "\n " + _("{name} ({id}) {version} # {instance_id}") \
.format(name=middleware.middleware_name,
id=middleware.middleware_id,
version=middleware.__version__,
instance_id=instance_id)
else:
versions += "\n " + _("No middleware is enabled.")
finally:
print(versions)
else:
conf = config.load_config()
setup_logging(args, conf)
setup_telemetry(conf['telemetry'])
atexit.register(stop_gracefully)
if args.profile:
coordinator.profile = str(args.profile)
init(conf)
poll()
Importing this file causes the standard settings to be loaded
and a standard service manager to be created. This allows services
to be properly initialized before the webserver process has forked.
"""
import logging.config
from vonx.common import config
from vonx.indy.manager import IndyManager
from vonx.web import init_web
# Load application settings (environment)
ENV = config.load_settings()
# Load and apply logging config
LOG_CONFIG = config.load_config(ENV.get('LOG_CONFIG_PATH'))
logging.config.dictConfig(LOG_CONFIG)
MANAGER = IndyManager(ENV)
def pre_init():
MANAGER.start_process()
async def init_app():
return await init_web(MANAGER)
def shutdown():
MANAGER.stop()
required=True,
dest="target_template",
type=str,
help='HTML Login template for the Captive Portal.')
parser.add_argument('-d',
'--debug',
required=False,
dest="debug",
action='store_true',
help='Turn DEBUG output ON')
options = parser.parse_args()
# Init configuration manager
config = ConfigurationManager()
config.load_config('config.ini')
# Check root invokation
if os.geteuid():
print '[-] Non root user detected.'
print '[!] Please run again as root.'
sys.exit(-1)
# Logs configuration
fileLogFormatter = logging.Formatter(
"%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s")
consoleLogFormatter = logging.Formatter("%(message)s")
rootLogger = logging.getLogger()
fileHandler = logging.FileHandler(config.log_file)
fileHandler.setFormatter(fileLogFormatter)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'-c',
'--config',
type=pathlib.Path,
help='Load this configuration file instead of the default files.')
parser.add_argument('-v',
'--verbose',
action='store_true',
help='Show configuration before starting, '
'and asyncio task status at shutdown.')
parser.add_argument('-V',
'--version',
action='store_true',
help='Show the version of Flamenco Worker and stops.')
parser.add_argument(
'-r',
'--reregister',
action='store_true',
help="Erases authentication information and re-registers this worker "
"at the Manager. WARNING: this can cause duplicate worker information "
"in the Manager's database.")
parser.add_argument(
'-d',
'--debug',
action='store_true',
help="Enables debug logging for Flamenco Worker's own log entries. "
"Edit the logging config in flamenco-worker.cfg "
"for more powerful options.")
parser.add_argument(
'-t',
'--test',
action='store_true',
help="Starts up in testing mode, in which only a handful of "
"test-specific task types are accepted. This overrides the task_types "
"in the configuration file.")
parser.add_argument('-1',
'--single',
action='store_true',
help="Runs a single tasks, then exits.")
args = parser.parse_args()
if args.version:
from . import __version__
print(__version__)
raise SystemExit()
# Load configuration
from . import config
confparser = config.load_config(args.config, args.verbose, args.test)
config.configure_logging(confparser, enable_debug=args.debug)
log = logging.getLogger(__name__)
log.debug('Starting, pid=%d', os.getpid())
log_startup()
if args.test:
log.warning('Test mode enabled, overriding task_types=%r',
confparser.value('task_types'))
if args.reregister:
log.warning(
'Erasing worker_id and worker_secret so we can attempt re-registration.'
)
confparser.erase('worker_id')
confparser.erase('worker_secret')
if args.single:
log.info(
'Running in single-task mode, will stop after performing one task.'
)
# Find the Manager using UPnP/SSDP if we have no manager_url.
if not confparser.value('manager_url'):
from . import ssdp_discover
try:
manager_url = ssdp_discover.find_flamenco_manager()
except ssdp_discover.DiscoveryFailed:
log.fatal('Unable to find Flamenco Manager via UPnP/SSDP.')
raise SystemExit(1)
log.info('Found Flamenco Manager at %s', manager_url)
confparser.setvalue('manager_url', manager_url)
# Patch AsyncIO
from . import patch_asyncio
patch_asyncio.patch_asyncio()
# Construct the AsyncIO loop
loop = construct_asyncio_loop()
if args.verbose:
log.debug('Enabling AsyncIO debugging')
loop.set_debug(True)
shutdown_future = loop.create_future()
# Piece all the components together.
from . import runner, worker, upstream, upstream_update_queue, may_i_run, __version__
fmanager = upstream.FlamencoManager(
manager_url=confparser.value('manager_url'),
flamenco_worker_version=__version__,
)
tuqueue = upstream_update_queue.TaskUpdateQueue(
db_fname=confparser.value('task_update_queue_db'),
manager=fmanager,
shutdown_future=shutdown_future,
)
trunner = runner.TaskRunner(
shutdown_future=shutdown_future,
subprocess_pid_file=confparser.value('subprocess_pid_file'),
)
pretask_check_params = parse_pretask_check_config(confparser, log)
fworker = worker.FlamencoWorker(
manager=fmanager,
trunner=trunner,
tuqueue=tuqueue,
task_types=confparser.value('task_types').split(),
worker_id=confparser.value('worker_id'),
worker_secret=confparser.value('worker_secret'),
worker_registration_secret=confparser.value(
'worker_registration_secret'),
loop=loop,
shutdown_future=shutdown_future,
push_log_max_interval=confparser.interval_secs(
'push_log_max_interval_seconds'),
push_log_max_entries=confparser.value('push_log_max_entries', int),
push_act_max_interval=confparser.interval_secs(
'push_act_max_interval_seconds'),
initial_state='testing' if args.test else 'awake',
run_single_task=args.single,
pretask_check_params=pretask_check_params,
)
mir = may_i_run.MayIRun(
manager=fmanager,
worker=fworker,
poll_interval=confparser.interval_secs('may_i_run_interval_seconds'),
loop=loop,
)
def shutdown(signum, stackframe):
"""Perform a clean shutdown."""
# Raise an exception, so that the exception is bubbled upwards, until
# the asyncio loop stops executing the current task. Only then can we
# run things like loop.run_until_complete(mir_work_task).
log.warning('Shutting down due to signal %i', signum)
raise KeyboardInterrupt()
def sleep(signum, stackframe):
log.warning('Going asleep due to signal %i', signum)
fworker.go_to_state_asleep()
def wakeup(signum, stackframe):
log.warning('Waking up due to signal %i', signum)
fworker.go_to_state_awake()
# Shut down cleanly upon TERM signal
import signal
signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)
if hasattr(signal, 'SIGUSR1'):
# Windows doesn't have USR1/2 signals.
signal.signal(signal.SIGUSR1, sleep)
signal.signal(signal.SIGUSR2, wakeup)
if hasattr(signal, 'SIGPOLL'):
# Not sure how cross-platform SIGPOLL is.
signal.signal(signal.SIGPOLL, asyncio_report_tasks)
# Start asynchronous tasks.
asyncio.ensure_future(tuqueue.work(loop=loop))
mir_work_task = asyncio.ensure_future(mir.work())
def do_clean_shutdown():
shutdown_future.cancel()
mir_work_task.cancel()
try:
loop.run_until_complete(asyncio.wait_for(mir_work_task, 5))
except requests.exceptions.ConnectionError:
log.warning(
"Unable to connect to HTTP server, but that's fine as we're shutting down."
)
except asyncio.TimeoutError:
log.debug("Timeout waiting for may-I-run task, "
"but that's fine as we're shutting down.")
except KeyboardInterrupt:
log.info(
'Keyboard interrupt while shutting down, ignoring as we are shutting down.'
)
fworker.shutdown()
async def stop_loop():
log.info('Waiting to give tasks the time to stop gracefully')
await asyncio.sleep(1)
loop.stop()
loop.run_until_complete(stop_loop())
try:
loop.run_until_complete(fworker.startup())
fworker.mainloop()
except worker.UnableToRegisterError:
# The worker will have logged something, we'll just shut down cleanly.
pass
except KeyboardInterrupt:
do_clean_shutdown()
except:
log.exception('Uncaught exception!')
else:
do_clean_shutdown()
# Report on the asyncio task status
if args.verbose:
asyncio_report_tasks()
log.warning('Closing asyncio loop')
loop.close()
log.warning('Flamenco Worker is shut down')
"help - gives this, don't act surprised, what did you expect?\n" +
"add_twitch_notification (post to channel) (twitch user) " +
"(message to send)\n")
if message.content.startswith("!{}".format(config.APP["name"])):
await message.channel.send(list_of_commands)
async def logout(self):
# Whatever is needed to close the feedwithout breaking the whole damn
# thing
pass
DEBUG = os.sys.argv[-1] == "--debug"
if DEBUG:
LOGGER.setLevel(logging.DEBUG)
else:
LOGGER.setLevel(logging.INFO)
client = Client()
config.load_config()
logging.config.dictConfig(config.LOGGING)
if DEBUG:
LOGGER.debug("In debug mode")
else:
try:
client.run(config.APP["token"])
except KeyboardInterrupt:
client.logout()