def main():
server = make_app()
server.listen(options.port, options.address)
print('listening on ' + str(options.address) + ':' + str(options.port))
autoreload.start()
autoreload.watch(config_path.web)
IOLoop.instance().start()
def add_optional_autoreload_files(file_list: List[str]) -> None:
for filen in file_list:
if os.path.isdir(filen):
log.warning("Cannot watch directory " + filen)
continue
log.info("Watching: " + filen)
watch(filen)
def run(self, args):
settings = self.get_settings()
for name in map(basename, glob(join('controllers', '*.py'))):
autoreload.watch(name)
Module.load(self.get_controller_import_path(name))
from shrine.routes import make_application
MESSAGE = "{} running at http://localhost:{}\n".format(
settings.PRODUCT_NAME,
settings.PORT,
)
application = make_application()
application.listen(settings.PORT)
self.log.bold_green(MESSAGE)
from shrine.log import logger
logger.setLevel(logging.WARNING)
try:
autoreload.start()
IOLoop.instance().start()
except KeyboardInterrupt:
self.log.bold_red_on_black("\rInterrupted by the User (Control-C)\n")
def static_watcher():
for dir, sub, files in os.walk(sys.path[0]):
if dir[0:3] == './.': # ignore dirname == '.\w'
continue
for f in files:
if f[0] != '.': # ignore filename == '.\w'
autoreload.watch(os.path.abspath(os.path.join(dir, f)))
def start_thememapper():
global nav
global mapper
#initialize the necessary classes
mapper = Mapper(get_settings())
nav = Navigation()
# Adds the ability to set config file and port through commandline
p = optparse.OptionParser()
p.add_option('--port', '-p', default=mapper.port,help='port thememapper should run at')
p.add_option('--diazo', '-d', default=False,action="store_true",dest="diazo",help='force diazo server to run')
p.add_option('--diazo_port', '-f', default=mapper.diazo_port,help='port diazo should run at')
options = p.parse_args()[0]
mapper.port = options.port
mapper.diazo_port = options.diazo_port
#start thememapper
print "Starting thememapper on http://0.0.0.0:" + mapper.port
HTTPServer(WSGIContainer(app)).listen(mapper.port)
if options.diazo or mapper.diazo_run == 'True':
try:
from thememapper.diazo import server
print "Starting diazo on http://0.0.0.0:" + mapper.diazo_port
HTTPServer(server.get_application(mapper)).listen(mapper.diazo_port)
except ImportError:
print "You will need to install thememapper.diazo before being able to use this function."
ioloop = IOLoop.instance()
autoreload.watch(os.path.join(os.path.dirname(__file__), 'settings.properties'))
autoreload.add_reload_hook(reload)
autoreload.start(ioloop)
ioloop.start()
def add_optional_autoreload_files(file_list):
for filen in file_list:
if os.path.isdir(filen):
log.warning("Cannot watch directory " + filen)
continue
log.info("Watching: " + filen)
watch(filen)
def enable_autoreload(self, watch_dirs=list()):
for current_dir in watch_dirs:
if not os.path.isdir(current_dir):
continue
for (path, dirs, files) in os.walk(current_dir):
for item in files:
autoreload.watch(os.path.join(path, item))
autoreload.start(self.__io_loop)
def _add_watch_path(path: pathlib.Path) -> None:
if _is_exclude(path.name):
return
elif path.is_dir():
for f in path.iterdir():
_add_watch_path(f)
elif path.is_file():
autoreload.watch(str(path))
def enable_autoreload(self, watch_dirs=list()):
for current_dir in watch_dirs:
if not os.path.isdir(current_dir):
continue
for (path, dirs, files) in os.walk(current_dir):
for item in files:
autoreload.watch(os.path.join(path, item))
autoreload.start(self.__io_loop)
def static_watcher(path):
global _base_path
_base_path = os.path.abspath(path)
for dir, sub, files in os.walk(path):
if dir[0:3] != './.': # ignore dirname == '.\w'
for f in files:
if f[0] != '.': # ignore filename == '.\w'
autoreload.watch(os.path.abspath(os.path.join(dir, f)))
def _add_watch_path(path: pathlib.Path):
if _is_exclude(path.name):
return
elif path.is_dir():
for f in path.iterdir():
_add_watch_path(f)
elif path.is_file():
autoreload.watch(str(path))
def main():
server.git = git.bake(_cwd=server.settings.repo)
if options.listen_localhost_only:
server.listen(options.port, 'localhost')
else:
server.listen(options.port)
autoreload.start()
autoreload.watch(config_path.web)
IOLoop.instance().start()
def find_autoreload_targets(app_path: str) -> None:
path = os.path.abspath(app_path)
if not os.path.isdir(path):
return
for path, subdirs, files in os.walk(path):
for name in files:
if (fnmatch(name, '*.html') or fnmatch(name, '*.css')
or fnmatch(name, '*.yaml')):
log.info("Watching: " + os.path.join(path, name))
watch(os.path.join(path, name))
def legacy_bootstrap(config):
# Compat with legacy load_plugins
config.plugins = {}
autoreload.watch(config.temboard.configfile)
# Run temboard as a background daemon.
if config.temboard.daemonize:
daemonize(config.temboard.pidfile, config)
return config
def load_react_assets():
try:
fn = options.react_assets_file
with open(fn) as f:
watch(fn)
assets = json.load(f)
except IOError:
assets = None
except KeyError:
assets = None
return assets
def find_autoreload_targets(app_path):
path = os.path.abspath(app_path)
if not os.path.isdir(path):
return
for path, subdirs, files in os.walk(path):
for name in files:
if (fnmatch(name, '*.html') or
fnmatch(name, '*.css') or
fnmatch(name, '*.yaml')):
log.info("Watching: " + os.path.join(path, name))
watch(os.path.join(path, name))
def main(vixen):
html_file = join(dirname(__file__), 'html', 'vixen_ui.html')
template = Template(html_file=html_file, base_url='/', async=True)
ioloop = IOLoop.instance()
app = WebApp(
template=template, context={'vixen':vixen}, port=8000,
autoreload=True
)
autoreload.watch(html_file)
app.listen(8000)
url = 'http://localhost:8000'
print "Point your browser to", url
ioloop.start()
def main():
tornado.options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application())
http_server.listen(options.port)
from tornado import autoreload
autoreload.watch("templates/home.html")
autoreload.watch("templates/users.html")
autoreload.watch("templates/changepassword.html")
autoreload.watch("templates/register.html")
autoreload.watch("templates/register_stepone.html")
autoreload.start()
tornado.ioloop.IOLoop.instance().start()
def _load_inclusion(self, inclusion):
source_location = inclusion.attribute('src')
if source_location[0] != '/':
source_location = os.path.join(self._config_base_path, source_location)
pre_config = load_from_file(source_location)
self._configure(pre_config, source_location)
watch(source_location)
self._logger.info('Included the configuration from %s' % source_location)
def __init__(self, configuration_location, **settings):
BaseApplication.__init__(self, **settings)
self._config_main_path = os.path.join(self._base_path, configuration_location)
self._config_base_path = os.path.dirname(self._config_main_path)
self._config = load_from_file(self._config_main_path)
# Initialize the routing map
self._routing_map = RoutingMap()
# Default properties
self._scope = settings['scope'] if 'scope' in settings else None
self._port = 8000
# Register the default services.
self._register_default_services()
# Add the main configuration to the watch list.
watch(self._config_main_path)
# Configure the included files first.
for inclusion in self._config.children('include'):
source_location = inclusion.attribute('src')
if source_location[0] != '/':
source_location = os.path.join(self._config_base_path, source_location)
pre_config = load_from_file(source_location)
self._configure(pre_config, source_location)
watch(source_location)
self._logger.info('Included the configuration from %s' % source_location)
self._configure(self._config)
# Override the properties with the parameters.
if 'port' in settings:
self._port = settings['port']
self._logger.info('Changed the listening port: %s' % self._port)
# Update the routing map
AppServices.get('routing_map').update(self._routing_map)
# Normal procedure
self._update_routes(self._routing_map.export())
self.listen(self._port)
self._activate()
def _load_new_style_configuration(self, configuration):
# Load the data directly from a JSON file.
for inclusion in configuration.children('use'):
source_location = inclusion.attribute('src')
if source_location[0] != '/':
source_location = os.path.join(self._config_base_path, source_location)
with open(source_location) as f:
decoded_config = json.load(f)
self._override_sub_config_tree(self._settings, decoded_config)
watch(source_location)
def initalize_webpack():
from tornado import autoreload
try:
fn = 'webpack-assets.json'
with open(fn) as f:
autoreload.watch(fn)
assets = json.load(f)
define('ASSETS', assets)
except IOError:
pass
except KeyError:
pass
def legacy_bootstrap(config):
# Compat with legacy load_plugins
config.plugins = {}
logging.config.dictConfig(
generate_logging_config(systemd='SYSTEMD' in os.environ,
**config.logging))
logger.info("Starting main process.")
autoreload.watch(config.temboard.configfile)
# Run temboard as a background daemon.
if config.temboard.daemonize:
daemonize(config.temboard.pidfile, config)
return config
def __init__(self, configuration_location, **settings):
BaseApplication.__init__(self, **settings)
self._service_assembler = ImaginationAssembler(ImaginationTransformer(AppServices))
self._config_main_path = os.path.join(self._base_path, configuration_location)
self._config_base_path = os.path.dirname(self._config_main_path)
self._config = load_from_file(self._config_main_path)
# Initialize the routing map
self._routing_map = RoutingMap()
# Default properties
self._scope = settings['scope'] if 'scope' in settings else None
self._port = 8000
# Register the default services.
self._register_default_services()
# Add the main configuration to the watch list.
watch(self._config_main_path)
# Configure with the configuration files
self._service_assembler.activate_passive_loading()
for inclusion in self._config.children('include'):
self._load_inclusion(inclusion)
self._configure(self._config)
self._prepare_db_connections()
self._prepare_session_manager()
self._service_assembler.deactivate_passive_loading()
# Override the properties with the parameters.
if 'port' in settings:
self._port = settings['port']
self._logger.info('Changed the listening port: %s' % self._port)
# Update the routing map
AppServices.get('routing_map').update(self._routing_map)
# Normal procedure
self._update_routes(self._routing_map.export())
self.listen(self._port)
self._activate()
def __init__(self, world):
self.world = world
self._id = itertools.count(1)
self._entities = {}
self._components = collections.defaultdict(set)
if os.path.exists(ARCHETYPES):
from tornado import autoreload
autoreload.watch(ARCHETYPES)
with open(ARCHETYPES) as f:
self._archetypes = {}
archetypes = yaml.load(f.read())
for name in venom.utils.topsort({name: archetype.get('extend') for name, archetype in archetypes.items()}):
archetype = archetypes[name]
components = {}
if 'extend' in archetype:
components = self._archetypes[archetype['extend']].copy()
if 'components' in archetype:
for component, kwargs in archetype['components'].items():
pieces = component.split('.')
module = importlib.import_module('.'.join(pieces[:-1]))
try:
cls = getattr(module, pieces[-1])
if cls not in components:
components[cls] = kwargs
else:
components[cls] = components[cls].copy()
components[cls].update(kwargs)
except Exception:
logger.error('Unknown component "%s"' % component)
exit(0)
self._archetypes[name] = components
def run(self) -> None:
self.settings.setup_elasticsearch_connection()
# The following is a simpler `bokeh serve src/nasty_analysis/visualization`.
# Code for that is in `bokeh.commands.subcommands.serve.Serve.invoke`.
# Also Bokeh provides this example:
# https://github.com/bokeh/bokeh/blob/2.0.2/examples/howto/server_embed/standalone_embed.py
address = self.settings.analysis.serve.address
port = self.settings.analysis.serve.port
num_procs = self.settings.analysis.num_procs
autoreload = False
if self.develop:
num_procs = 1
autoreload = True
watch(str(self.settings.find_settings_file()))
for file in Path(nasty_analysis.__file__).parent.glob("**/*.js"):
watch(str(file))
application = ParameterPassingApplication(
DirectoryHandler(filename=Path(serve.__file__).parent),
server_context_params={"settings": self.settings},
)
with report_server_init_errors(address=address, port=port):
server = Server(
{"/": application},
address=address,
port=port,
allow_websocket_origin=[f"{address}:{port}"],
num_procs=num_procs,
autoreload=autoreload,
)
server.start()
if self.show:
server.io_loop.add_callback(server.show, "/")
server.run_until_shutdown()
def run(self):
sys.path.insert(0, self.projectPath)
os.chdir(self.projectPath)
print(self.projectPath)
if self.apps_ports:
for x in self.projectConfig['BACKEND']:
current_port = self.projectConfig['BACKEND'][x]['port']
handlers_app = importlib.import_module(
"backapps.{0}.handlers".format(x))
if isinstance(handlers_app.HANDLER, (list, tuple)):
app = web.Application(handlers_app.HANDLER,
**handlers_app.SETTINGS)
app_http_server = httpserver.HTTPServer(app)
app_http_server.listen(int(current_port))
else:
app = handlers_app.HANDLER
app_http_server = httpserver.HTTPServer(app)
app_http_server.listen(int(current_port))
for x in self.projectConfig['FRONTEND']:
current_port = self.projectConfig['FRONTEND'][x]['port']
handlers_app = importlib.import_module(
"frontapps.{0}.handlers".format(x))
if isinstance(handlers_app.HANDLER, (list, tuple)):
app = web.Application(handlers_app.HANDLER,
**handlers_app.SETTINGS)
app_http_server = httpserver.HTTPServer(app)
app_http_server.listen(int(current_port))
else:
app = handlers_app.HANDLER
app_http_server = httpserver.HTTPServer(app)
app_http_server.listen(int(current_port))
autoreload.watch(os.path.join(self.projectPath, "config.json"))
ioloop.IOLoop.current().start()
print("start stopped")
ioloop.IOLoop.current().add_callback(
lambda: ioloop.IOLoop.current().close(True))
print("close? Don't know")
def main():
tornado.options.parse_command_line()
app = Application()
app.listen(options.port)
main_loop= tornado.ioloop.IOLoop.instance()
#tornado.ioloop.PeriodicCallback(test2, 5000).start()
tornado.ioloop.PeriodicCallback(updateEvents, PERIOD).start()
#main_loop.add_timeout(datetime.timedelta(seconds=5), test)
#remove in prod
autoreload.start(main_loop)
dirstowatch=['/vagrant/smartevents/static','/vagrant/smartevents/templates']
for directory in dirstowatch:
for dir, _, files in os.walk(directory):
[autoreload.watch(dir + '/' +f) for f in files if not f.startswith('.')]
main_loop.start()
def main():
tornado.options.parse_command_line()
app = Application()
app.listen(options.port)
main_loop = tornado.ioloop.IOLoop.instance()
#tornado.ioloop.PeriodicCallback(test2, 5000).start()
tornado.ioloop.PeriodicCallback(updateEvents, PERIOD).start()
#main_loop.add_timeout(datetime.timedelta(seconds=5), test)
#remove in prod
autoreload.start(main_loop)
dirstowatch = [
'/vagrant/smartevents/static', '/vagrant/smartevents/templates'
]
for directory in dirstowatch:
for dir, _, files in os.walk(directory):
[
autoreload.watch(dir + '/' + f) for f in files
if not f.startswith('.')
]
main_loop.start()
from messanger.handlers.socket import MessagesSocketHandler
from messanger.handlers.api import GetContacts, GetChat
application = tornado.web.Application([
(r"/", MainHandler),
(r"/messages", MessagesSocketHandler),
(r"/api/account/(.+)/contacts", GetContacts),
(r"/api/chat/(.+)/(.+)", GetChat),
(r"/chat/(.+)/", ChatHandler),
],
static_path='static',
debug=True)
if __name__ == "__main__":
assets = None
try:
fn = '../webpack-assets.json'
with open(fn) as f:
watch(fn)
assets = json.load(f)
except IOError as e:
print("IOError: ", e)
pass
except KeyError as e:
print("KeyError: ", e)
pass
define('ASSETS', assets)
application.listen(8888)
tornado.ioloop.IOLoop.current().start()
def __init__(self):
settings = dict(
static_path=os.path.join(
os.path.dirname(__file__),
"static"), # tell where to find static dir
template_path=os.path.join(os.path.dirname(__file__), 'templates'),
debug=True,
cookie_secret="61yUTzRANAGaYdkL5gEmChenxiYh7EQnp2XdTP1o/Vo=",
login_url="/login",
)
handlers = [(r'/', MainHandler), (r'/text', TextHandler),
(r"/login", LoginHandler), (r"/logout", LogoutHandler),
(r"/(apple-touch-icon\.png)", web.StaticFileHandler,
dict(path=settings['static_path']))]
conn = pymongo.MongoClient('localhost', 27017)
self.db = conn.page_text_db
web.Application.__init__(self, handlers, **settings)
if __name__ == '__main__':
# temp_dir = tempfile.mkdtemp(dir=os.path.join(os.path.dirname(__file__), "static"))
options.parse_command_line()
http_server = httpserver.HTTPServer(Application())
http_server.listen(options.port)
# TODO remove in prod
autoreload.start()
autoreload.watch('template.html es_method.py search_results.html')
ioloop.IOLoop.instance().start()
def __init__(self, config, watch, web_root, cache_index, debug=False):
autoreload.watch(config)
autoreload.watch(watch)
autoreload.add_reload_hook(self.before_reload_done)
self.log('config ' + config)
self.log('watch ' + watch)
self.load_config(config)
self.load_config(watch)
if not os.path.exists(os.path.dirname(cache_index)):
os.makedirs(os.path.dirname(cache_index))
self.settings['web_root'] = web_root
self.cache_index = cache_index
self.debug = debug
if self.debug:
self.log("debug is enabled")
self.log("config used: " + config)
self.log("web root: " + web_root)
self.log("cache index: " + cache_index)
self.cache = self.load_cache()
if self.settings['css_inlined'] != '':
self.settings['css_files'].append(self.settings['css_inlined'])
for f in self.settings['css_files']:
self.log('watch css ' + f)
autoreload.watch(self.get_file_path(f))
self.settings['js_files'].append(self.settings['js_loader'])
for f in self.settings['js_files']:
self.log('watch js [' + f['name'] + '] ' + f['file'])
if f['name'] != 'loader':
autoreload.watch(self.get_file_path(f['file']))
else:
autoreload.watch(f['file'])
if 'preload_templates' in self.settings:
loader = template.Loader(self.settings['templates_dir'])
for f in self.settings['preload_templates']:
self.log('watch template ' + f)
autoreload.watch(self.settings['templates_dir'] + f)
self.templates.append({'file': f, 'template': loader.load(f)})
self.recompile()
self.cache_css_inlined = self.get_inlined_css()
self.cache_css_js_loader = self.get_loader()
"thank you",
"agree",
"disagree",
"not constructive",
"troll",
"spam",
]
# start
if args.prod:
# run on Tornado instead, since running raw Flask in prod is not recommended
print("starting tornado!")
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.log import enable_pretty_logging
from tornado import autoreload
enable_pretty_logging()
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(args.port)
ioloop = IOLoop.instance()
# Auto-reload after modifying templates
autoreload.start()
autoreload.watch(Config.db_serve_path)
ioloop.start()
else:
print("starting flask!")
app.debug = False
app.run(port=args.port, host="0.0.0.0")
def main():
server.git = git.bake(_cwd=server.settings.repo)
server.listen(options.port, 'localhost')
autoreload.start()
autoreload.watch(config_path.web)
IOLoop.instance().start()
if sys.platform.startswith('win'):
base_url = ''
html_file = get_html_file()
html = get_html(html_file)
template = VueTemplate(html=html, base_url=base_url, async=async)
silence_tornado_access_log()
ioloop = IOLoop.instance()
if port is None:
if dev:
port = 8000
else:
from jigna.utils.web import get_free_port
port = get_free_port()
app = WebApp(template=template,
context=context,
port=port,
async=async,
autoreload=True)
autoreload.watch(html_file)
app.listen(port)
url = 'http://localhost:%d' % port
if dev:
print("Point your browser to", url)
else:
webbrowser.open(url)
if not test:
# When running tests, don't start the ioloop.
ioloop.start()
def watch(self, file=None):
if file is not None:
autoreload.watch(file)
def watch(self,file = None):
if file is not None:
autoreload.watch(file)
print(users)
@sio.event
def disconnect(sid):
print('disconnect ', sid)
sio.leave_room(sid, 'chat_users')
class SendMessageHandler(tornado.web.RequestHandler):
async def get(self):
data = {'data': 'bla'}
await sio.emit('ping', data, room='chat_users')
self.write("Hello, world")
def make_app():
return tornado.web.Application([
# test page
(r"/send", SendMessageHandler),
(r"/websocket/", socketio.get_tornado_handler(sio)),
])
if __name__ == "__main__":
print('Starting server on 8888 port')
autoreload.start()
autoreload.watch('tornado_server.py')
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
def main():
server = make_app()
server.listen(options.port, options.address)
autoreload.start()
autoreload.watch(config_path.web)
IOLoop.instance().start()
def run(self, *args, **kwargs):
"""Run bot."""
self.logger.info(cactus_art)
self._init_database(self.database)
self.load_config(filename=self.config_file)
self.load_stats(filename=self.stats_file)
while self.config.get("autorestart") or not self.started:
try:
self.bot_data = self.login(**self.config["auth"])
self.logger.info("Authenticated as: {}.".format(
self.bot_data["username"]))
self.started = True
self.channel = self.config["channel"]
self.channel_data = self.get_channel(self.channel)
self._init_commands()
self.connect(self.channel_data["id"],
self.bot_data["id"],
silent=self.silent)
self.connect_to_liveloading(self.channel_data["id"],
self.channel_data["userId"])
if str(self.debug).lower() in ("true", "debug"):
add_reload_hook(
partial(
self.send_message,
"Restarting, thanks to debug mode. :spaceship"))
watch(self.config_file)
start(check_time=5000)
IOLoop.instance().start()
except KeyboardInterrupt:
print()
self.logger.info("Removing thorns... done.")
try:
self.send_message("CactusBot deactivated! :cactus")
except Exception:
pass
finally:
exit()
except Exception:
self.logger.critical("Oh no, I crashed!")
try:
self.send_message("Oh no, I crashed! :127")
except Exception:
pass
self.logger.error('\n\n' + format_exc())
if self.config.get("autorestart"):
self.logger.info("Restarting in 10 seconds...")
try:
sleep(10)
except KeyboardInterrupt:
self.logger.info("CactusBot deactivated.")
exit()
else:
self.logger.info("CactusBot deactivated.")
exit()
# обработчик закрытия соединения клиентом
def on_close(self):
print('close connection')
# удаление соединения из глобального словаря
del ws_clients[self.client_id]
send_cliens_to_all()
# конфигурируем приложение роутингом
def make_app():
return tornado.web.Application([
# главная страница
(r"/", MainHandler),
# отдача статики
(r'/static/(.*)', tornado.web.StaticFileHandler, {
'path': 'static'
}),
# запросы по веб-сокету
(r"/websocket", WebsocketHandler),
])
if __name__ == "__main__":
print('Starting server on 8888 port')
autoreload.start()
autoreload.watch('.')
autoreload.watch('index.html')
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
def create_app():
try:
from plsys.wsgi import application
except ImportError, e:
print e
return None
return application
app = create_app()
if app is None:
print "Cannot import plsys"
sys.exit()
port = 8000 #if DEPLOYMENT_LEVEL == 'local' else 80
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(port)
ioloop = IOLoop.instance()
autoreload.start(ioloop)
watchlist = []
for dirpath,_,filenames in os.walk(BASE_DIR):
for f in filenames:
if f.endswith('.py'):
watchlist.append(os.path.abspath(os.path.join(dirpath, f)))
for file in watchlist:
autoreload.watch(file)
ioloop.start()
def watcher(fn, watchset=set()):
if fn not in watchset:
autoreload.watch(fn)
logging.debug("Autoreload: {}".format(fn))
watchset.add(fn)
def addwatchfiles(*paths):
for p in paths:
autoreload.watch(os.path.abspath(p))
def watch_directory(directory):
"""Adds a given directory to the autoreload watch list."""
for filename in os.listdir(directory):
watch(os.path.join(directory, filename))
def intialize_watcher(self):
self.watched_dirs = ["static/css", "static/js"]
if self.settings.get('debug'):
for wdir in self.watched_dirs:
for filename in os.listdir(wdir):
autoreload.watch(os.path.abspath(os.path.join(wdir, filename)))
def seek_and_destroy(self):
for name in map(basename, glob(join('controllers', '*.py'))):
module_cache.append(
Module.load(self.get_controller_import_path(name)))
autoreload.watch(name)
"thank you",
"agree",
"disagree",
"not constructive",
"troll",
"spam",
]
# start
if args.prod:
# run on Tornado instead, since running raw Flask in prod is not recommended
print("starting tornado!")
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.log import enable_pretty_logging
from tornado import autoreload
enable_pretty_logging()
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(args.port)
ioloop = IOLoop.instance()
# Auto-reload after modifying templates
autoreload.start()
autoreload.watch(Config.db_serve_path)
ioloop.start()
else:
print("starting flask!")
app.debug = False
app.run(port=args.port, host="0.0.0.0")
def run(self, *args, **kwargs):
"""Run bot."""
self.logger.info(cactus_art)
self._init_database(self.database)
self.load_config(filename=self.config_file)
self.load_stats(filename=self.stats_file)
while self.config.get("autorestart") or not self.started:
try:
self.bot_data = self.login(**self.config["auth"])
self.logger.info("Authenticated as: {}.".format(
self.bot_data["username"]))
self.started = True
self.channel = self.config["channel"]
self.channel_data = self.get_channel(self.channel)
self._init_commands()
self.connect(
self.channel_data["id"],
self.bot_data["id"],
silent=self.silent)
self.connect_to_liveloading(
self.channel_data["id"],
self.channel_data["userId"])
if str(self.debug).lower() in ("true", "debug"):
add_reload_hook(partial(
self.send_message,
"Restarting, thanks to debug mode. :spaceship"
))
watch(self.config_file)
start(check_time=5000)
IOLoop.instance().start()
except KeyboardInterrupt:
print()
self.logger.info("Removing thorns... done.")
try:
self.send_message("CactusBot deactivated! :cactus")
except Exception:
pass
finally:
exit()
except Exception:
self.logger.critical("Oh no, I crashed!")
try:
self.send_message("Oh no, I crashed! :127")
except Exception:
pass
self.logger.error('\n\n' + format_exc())
if self.config.get("autorestart"):
self.logger.info("Restarting in 10 seconds...")
try:
sleep(10)
except KeyboardInterrupt:
self.logger.info("CactusBot deactivated.")
exit()
else:
self.logger.info("CactusBot deactivated.")
exit()
# entry point to start our app
# python imports
import os
# external imports
from tornado import autoreload
from tornado.ioloop import IOLoop
# local imports
from services.app import make_app
# Main function
if __name__ == '__main__':
# Define application
config_name = os.getenv('APP_SETTINGS')
app = make_app(debug=True)
app.listen(eval(os.getenv('TORNADO_PORT')))
autoreload.start()
autoreload.watch(
os.path.join(os.path.dirname(__file__), os.getenv('MODELS_PATH')))
IOLoop.instance().start()
# and cache it in file
print('writing search_dict.p as cache')
utils.safe_pickle_dump(SEARCH_DICT, 'search_dict.p')
else:
print('loading cached index for faster search...')
SEARCH_DICT = pickle.load(open('search_dict.p', 'rb'))
# start
if args.prod:
# run on Tornado instead, since running raw Flask in prod is not recommended
print('starting tornado!')
from tornado import autoreload
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.log import enable_pretty_logging
enable_pretty_logging()
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(args.port)
ioloop = IOLoop.instance()
#autoreload.watch("templates/main.html")
autoreload.watch("db.p")
autoreload.start()
ioloop.start()
autoreload.wait()
else:
print('starting flask!')
app.debug = True
app.run(port=args.port)
])
'''
app.listen(args.listen_port, args.listen_interface, ssl_options={
"certfile": os.path.join(lib_dir, "mydomain.crt"),
"keyfile": os.path.join(lib_dir, "mydomain.key"),
})
'''
from backend.local import IS_SSL_SERVER
if __name__ == "__main__":
print('Starting server on 8888 port')
autoreload.start()
autoreload.watch('socket_server.py')
app = make_app()
if IS_SSL_SERVER:
app.listen(8888,
ssl_options={
"certfile": '/home/webmaster/cert1.pem',
"keyfile": '/home/webmaster/privkey1.pem',
})
else:
app.listen(8888)
loop = IOLoop.current()
loop.add_callback(setup)
#loop.instance().spawn_callback(small_loop)
loop.start()
def main():
server = make_app()
server.listen(options.port, options.address)
autoreload.start()
autoreload.watch(config_path.web)
IOLoop.instance().start()
def get(self):
self.render('index.html', data=None )
class StateLiteracy(tornado.web.RequestHandler):
def get(self):
data = pd.read_csv('state-literacy.csv')
self.render('index.html', data=data.to_html())
class GenderLiteracy(tornado.web.RequestHandler):
def get(self):
data = pd.read_csv('gender-literacy.csv')
self.render('index.html', data=data.to_html())
if __name__ == '__main__':
tornado.options.parse_command_line()
for d in os.listdir(os.getcwd()):
autoreload.watch(os.path.abspath(os.path.abspath(d)))
app = tornado.web.Application(handlers=[(r'/', MainHandler),
(r'/state', StateLiteracy),
(r'/gender', GenderLiteracy)],
autoreload=True,
templates_path=os.getcwd(),
static_path=os.getcwd())
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
del data['monster_table'][0]
del data['flair_posts'][0]
del data['ignores'][0]
del data['deletes'][0]
del data['revisits'][0]
self.send(json.dumps(data))
def on_close(self):
mdb.close()
DBRouter = SockJSRouter(DBConnection, '/tamabot/db')
GraphRouter = SockJSRouter(GraphConnection, '/tamabot/graph')
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static")
}
app = web.Application([
(r'/tamabot/', MainHandler),
(r'/tamabot/(pure\.css)', web.StaticFileHandler, dict(path=settings['static_path'])),
(r'/tamabot/(style\.css)', web.StaticFileHandler, dict(path=settings['static_path'])),
(r'/tamabot/(tamabot\.png)', web.StaticFileHandler, dict(path=settings['static_path'])),
(r'/tamabot/(tamabot2\.png)', web.StaticFileHandler, dict(path=settings['static_path'])),
] + DBRouter.urls + GraphRouter.urls, **settings)
server = httpserver.HTTPServer(app)
server.listen(8008)
for dir, _, files in os.walk('tamabot/static'):
[autoreload.watch(dir + '/' + f) for f in files if not f.startswith('.')]
ioloop.IOLoop.instance().start()
import json
from tornado.options import options, define
from tornado.autoreload import watch
from jinja2 import Environment, FileSystemLoader
env = Environment(loader=FileSystemLoader("templates"))
class MainHandler(tornado.web.RequestHandler):
def get(self):
template = env.get_template("index.html")
self.write(template.render({"assets": options.ASSETS}))
application = tornado.web.Application([(r"/", MainHandler)], static_path="static", debug=True)
if __name__ == "__main__":
try:
fn = "webpack-assets.json"
with open(fn) as f:
watch(fn)
assets = json.load(f)
except IOError:
pass
except KeyError:
pass
define("ASSETS", assets)
application.listen(8888)
tornado.ioloop.IOLoop.current().start()
def watcher(fn, watchset=set()):
if fn not in watchset:
autoreload.watch(fn)
logging.debug("Autoreload: {}".format(fn))
watchset.add(fn)
super().__init__(app_handlers, **app_settings)
def log_request(self, request):
"""Override default to avoid logging requests"""
pass
if __name__ == "__main__":
boat = BoatPi(app_settings["boatpi_ws"], 5)
boatLogger = MongoLogger()
if app_settings["env"] == "dev":
boatLogger.clear_logs()
log.info("Starting applications", mode="single")
Application().listen(app_settings["port"])
autoreload.start()
autoreload.watch(r'assets/')
autoreload.watch(r'templates/')
autoreload.watch(r'templates/modules/')
else:
log.info("Starting applications", mode="forked", cpu_count=cpu_count())
server = HTTPServer(Application())
server.bind(app_settings["port"])
server.start(0) # multi process mode (one process per cpu)
ioloop = IOLoop.instance()
ioloop.start()
