def main():
logging.getLogger('tornado.access').propagate = False
parse_command_line()
if options.ioloop:
IOLoop.configure(options.ioloop)
for _ in range(options.num_runs):
run()
def setup_logger(logger_name, log_file, level=logging.INFO):
l = logging.getLogger(logger_name)
formatter = logging.Formatter('%(asctime)s : %(message)s')
fileHandler = logging.FileHandler(log_file, mode='a')
fileHandler.setFormatter(formatter)
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(formatter)
l.setLevel(level)
l.addHandler(fileHandler)
l.addHandler(streamHandler)
def __init__(self):
"""
Class constructor. Sets up logging, active handlers and application server
"""
# Set up log file, level and formatting
options.log_file_prefix = config.get('logging', 'path')
options.logging = config.get('logging', 'level')
options.log_to_stderr = config.getboolean('logging', 'stderr')
# Port and arguments
port = config.get('server', 'port')
define('port', default=port, help='Port to be used')
parse_command_line([])
# Override default logging format and date format
log_format = config.get('logging', 'fmt', raw=True)
date_format = config.get('logging', 'datefmt', raw=True)
if date_format:
formatter = tornado.log.LogFormatter(fmt=log_format,
datefmt=date_format)
for logger in logging.getLogger('').handlers:
logging.info('Overriding log format for %s' % (logger))
logger.setFormatter(formatter)
# Defining handlers
# Removing optional handlers from handler list
filtered_handlers = self.__handler_filter(handlers, config,
optionalConfig)
logging.info("Defining application (url, handler) pairs")
application = tornado.web.Application(filtered_handlers,
debug=config.getboolean(
'tornado', 'debug'))
# Configuring server and SSL
logging.info("Configuring HTTP server")
if (config.has_section('ssl')):
http_server = HTTPServer(application,
ssl_options={
"certfile":
config.get('ssl', 'hostcert'),
"keyfile":
config.get('ssl', 'hostkey'),
})
else:
http_server = HTTPServer(application)
logging.info("Host certificate undefined, SSL is DISABLED")
# Listening port
http_server.listen(options.port)
# Starting
logging.info("Starting application on port: " + str(port))
tornado.ioloop.IOLoop.instance().start()
def initialize_logging(application):
for stream_name in ['access', 'general', 'application']:
stream = logging.getLogger("tornado.%s" % stream_name)
stream.setLevel(getattr(logging, settings.LOG_LEVEL))
if not os.path.exists(settings.LOG_PATH):
os.makedirs(settings.LOG_PATH)
channel = logging.handlers.RotatingFileHandler(filename=os.path.join(
settings.LOG_PATH, "%s.%s.log" % (application, stream_name)), )
channel.setFormatter(LogFormatter(color=True))
stream.addHandler(channel)
def initialize_logging():
for stream_name in ['access', 'general', 'application']:
stream = logging.getLogger("tornado.%s" % stream_name)
stream.setLevel(getattr(logging, settings.LOG_LEVEL))
if not os.path.exists(settings.LOG_PATH):
os.makedirs(settings.LOG_PATH)
channel = logging.handlers.RotatingFileHandler(
filename=os.path.join(settings.LOG_PATH, "sems.%s.log" % stream_name),
)
channel.setFormatter(LogFormatter(color=True))
stream.addHandler(channel)
def __init__(self):
"""
Class constructor. Sets up logging, active handlers and application server
"""
# Set up log file, level and formatting
options.log_file_prefix = config.get('logging', 'path')
options.logging = config.get('logging', 'level')
options.log_to_stderr = config.getboolean('logging', 'stderr')
# Port and arguments
port = config.get('server', 'port')
define('port', default=port, help='Port to be used')
parse_command_line([])
# Override default logging format and date format
log_format = config.get('logging', 'fmt', raw = True)
date_format = config.get('logging', 'datefmt', raw = True)
if date_format:
formatter = tornado.log.LogFormatter(fmt = log_format, datefmt = date_format)
for logger in logging.getLogger('').handlers:
logging.info('Overriding log format for %s' % (logger))
logger.setFormatter(formatter)
# Defining handlers
# Removing optional handlers from handler list
filtered_handlers = self.__handler_filter(handlers, config, optionalConfig)
logging.info("Defining application (url, handler) pairs")
application = tornado.web.Application(filtered_handlers,
debug = config.getboolean('tornado', 'debug'))
# Configuring server and SSL
logging.info("Configuring HTTP server")
if (config.has_section('ssl')):
http_server = HTTPServer(application,
ssl_options = {
"certfile" : config.get('ssl', 'hostcert') ,
"keyfile" : config.get('ssl', 'hostkey'),
})
else:
http_server = HTTPServer(application)
logging.info("Host certificate undefined, SSL is DISABLED")
# Listening port
http_server.listen(options.port)
# Starting
logging.info("Starting application on port: " + str(port))
tornado.ioloop.IOLoop.instance().start()
import os
from tornado.log import LogFormatter
from tornado.log import logging
from microservicesutils import settings
general = logging.getLogger('tornado.general')
application = logging.getLogger('tornado.application')
access = logging.getLogger('tornado.access')
def initialize_logging(application):
for stream_name in ['access', 'general', 'application']:
stream = logging.getLogger("tornado.%s" % stream_name)
stream.setLevel(getattr(logging, settings.LOG_LEVEL))
if not os.path.exists(settings.LOG_PATH):
os.makedirs(settings.LOG_PATH)
channel = logging.handlers.RotatingFileHandler(filename=os.path.join(
settings.LOG_PATH, "%s.%s.log" % (application, stream_name)), )
channel.setFormatter(LogFormatter(color=True))
stream.addHandler(channel)
import tornado.httpclient
import redis
from tornado.options import options
import tornado.gen
from tornado.log import logging
import os
r = redis.Redis(host=os.environ.get("REDIS_PORT_6379_TCP_ADDR", "localhost"))
logger = logging.getLogger('fetcher')
logger.setLevel(logging.DEBUG)
@tornado.gen.coroutine
def get_data(key):
"""
return None or the data in the redis cache
"""
global r
try:
cached = r.get(key)
return cached.decode() if cached else None
except Exception as e:
logging.exception(e)
logging.warn('Fail to connect to the redis cache server')
return None
@tornado.gen.coroutine
def write_data(key, value, timeout):
from flask import Flask
from flask_restful import Api
from flask_mongoengine import MongoEngine
from tornado.log import logging, enable_pretty_logging
app = Flask(__name__)
app.config.from_object('zfs_cluster_deployer.config')
CONFIGS = app.config
DataBase = MongoEngine(app)
api = Api(app)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
enable_pretty_logging()
from zfs_cluster_deployer.application.Views import routes
import os
import json
import time
import builtins
import Conf
import random
import requests
import tornado.web
import tornado.ioloop
from tornado.log import logging
from tornado.options import define
from tornado.options import options
from tornado.options import parse_command_line
logger = logging.getLogger("tornado.application")
define("p", default=5000, help="server port", type=int)
WORDS = []
with open("words.json", 'r') as f:
data = json.load(f)
WORDS = data['words']
class Database(object):
def __init__(self, db_path):
self.db_path = db_path
self.data = {}
from rima import server
from tornado.log import logging
from urls import urls_map
logger = logging.getLogger(__name__)
import os
os.environ.setdefault("RIMA_SETTINGS_MODULE", "settings")
if __name__ == '__main__':
logger.debug("in api")
server.main(urls_map)
from rima import server
from tornado.log import logging
from urls import urls_map
logger = logging.getLogger(__name__)
import os
os.environ.setdefault("RIMA_SETTINGS_MODULE", "settings")
if __name__ == '__main__':
logger.debug("in api")
server.main(urls_map)
custom = {}
def setup_logger(logger_name, log_file, level=logging.INFO):
l = logging.getLogger(logger_name)
formatter = logging.Formatter('%(asctime)s : %(message)s')
fileHandler = logging.FileHandler(log_file, mode='a')
fileHandler.setFormatter(formatter)
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(formatter)
l.setLevel(level)
l.addHandler(fileHandler)
l.addHandler(streamHandler)
setup_logger('notifications', r'/bakkle/log/notifications.log')
nlog = logging.getLogger('notifications')
nlog.info('testNotifyDevice launched')
if __name__ == "__main__":
try:
device = Device.objects.get(pk=device_id)
print("Notifying {}".format(device.account_id.display_name))
device.send_notification(message=message,
badge=badge,
sound=sound,
custom=custom)
except Device.DoesNotExist:
print("Device does not exist")
import os
from tornado.log import LogFormatter
from tornado.log import logging
from sems import settings
general = logging.getLogger('tornado.general')
application = logging.getLogger('tornado.application')
access = logging.getLogger('tornado.access')
def initialize_logging():
for stream_name in ['access', 'general', 'application']:
stream = logging.getLogger("tornado.%s" % stream_name)
stream.setLevel(getattr(logging, settings.LOG_LEVEL))
if not os.path.exists(settings.LOG_PATH):
os.makedirs(settings.LOG_PATH)
channel = logging.handlers.RotatingFileHandler(
filename=os.path.join(settings.LOG_PATH, "sems.%s.log" % stream_name),
)
channel.setFormatter(LogFormatter(color=True))
stream.addHandler(channel)
import tornado.httpclient
import redis
from tornado.options import options
import tornado.gen
from tornado.log import logging
r = redis.Redis()
logger = logging.getLogger('fetcher')
logger.setLevel(logging.DEBUG)
@tornado.gen.coroutine
def get_data(key):
"""
return None or the data in the redis cache
"""
global r
try:
cached = r.get(key)
return cached.decode() if cached else None
except Exception as e:
logging.exception(e)
logging.warn('Fail to connect to the redis cache server')
return None
@tornado.gen.coroutine
def write_data(key, value, timeout):
global r
try:
