def list_routes() -> None:
output = []
app = create_app(parse_options())
app.config['SERVER_NAME'] = 'example.com'
with app.app_context():
for rule in app.url_map.iter_rules():
integer_replaces = {}
options = {}
integer = 0
for arg in rule.arguments:
options[arg] = str(integer)
integer_replaces[str(integer)] = "[{0}]".format(arg)
integer = +1
methods = ','.join(rule.methods)
url = flask.url_for(rule.endpoint, **options)
for integer_replace in integer_replaces:
url = url.replace(integer_replace,
integer_replaces[integer_replace])
line = urllib.parse.unquote("{:50s} {:20s} {}".format(
rule.endpoint, methods, url))
output.append(line)
for line in sorted(output):
print(line)
def celerydev():
setup_logging('celerydev')
app = create_app(parse_options(), no_sql=True)
Logging._setup = True # Disable Celery from setting up logging, already done in setup_logging().
celery_args = [
'celery', 'worker', '-B', '-s', '/tmp/celery.db', '--concurrency=5'
]
with app.app_context():
return celery_main(celery_args)
def server() -> None:
options = parse_options()
setup_logging('server',
logging.DEBUG if options.DEBUG else logging.WARNING)
app = create_app(options)
log_messages(app)
app.run(host=app.config['HOST'],
port=int(app.config['PORT']),
debug=app.config['DEBUG'],
threaded=True)
def celeryworker():
setup_logging('celeryworker{}'.format(OPTIONS['--name']))
app = create_app(parse_options(), no_sql=True)
Logging._setup = True
celery_args = [
'celery', 'worker', '-n', OPTIONS['--name'], '-C', '--autoscale=10,1',
'--without-gossip'
]
with app.app_context():
return celery_main(celery_args)
def celerybeat():
setup_logging('celerybeat')
app = create_app(parse_options(), no_sql=True)
Logging._setup = True
celery_args = [
'celery', 'beat', '-C', '--pidfile', OPTIONS['--pid'], '-s',
OPTIONS['--schedule']
]
with app.app_context():
return celery_main(celery_args)
def create_all() -> None:
setup_logging('create_all')
app = create_app(parse_options())
log = logging.getLogger(__name__)
with app.app_context():
tables_before = set(db.engine.table_names())
db.create_all()
tables_after = set(db.engine.table_names())
created_tables = tables_after - tables_before
for table in created_tables:
log.info('Created table: {}'.format(table))
def celerybeat():
options = parse_options()
setup_logging('celerybeat',
logging.DEBUG if options.DEBUG else logging.WARNING)
app = create_app(options, no_sql=True)
Logging._setup = True
celery_args = [
'celery', 'beat', '-C', '--pidfile', OPTIONS['--pid'], '-s',
OPTIONS['--schedule']
]
with app.app_context():
return celery_main(celery_args)
def post_install() -> None:
if not os.geteuid() == 0:
sys.exit('Script must be run as root')
app = create_app(parse_options())
config_path = os.path.join('/', 'etc', 'blacklist', 'config.yml')
configuration = {}
if os.path.isfile(config_path):
with open(config_path) as f:
loaded_data = yaml.load(f)
if isinstance(loaded_data, dict):
configuration.update(loaded_data)
# Generate database and config if nothing is specified
if 'SQLALCHEMY_DATABASE_URI' not in configuration or not configuration[
'SQLALCHEMY_DATABASE_URI']:
configuration[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:////home/blacklist/blacklist.db'
# We need to set DB config to make stamp work
app.config['SQLALCHEMY_DATABASE_URI'] = configuration[
'SQLALCHEMY_DATABASE_URI']
# Create empty database
with app.app_context():
db.create_all()
with app.app_context():
stamp()
# Generate secret key
if 'SECRET_KEY' not in configuration or not configuration['SECRET_KEY']:
app.config['SECRET_KEY'] = configuration[
'SECRET_KEY'] = random_password()
# Set port and host
if 'HOST' not in configuration or not configuration['HOST']:
configuration['HOST'] = '0.0.0.0'
if 'PORT' not in configuration or not configuration['PORT']:
configuration['PORT'] = 80
# Write new configuration
with open(config_path, 'w') as f:
yaml.dump(configuration,
f,
default_flow_style=False,
allow_unicode=True)
def migrations() -> None:
app = create_app(parse_options())
manager = Manager(app)
manager.add_command('migrations', MigrateCommand)
manager.run()
def setup() -> None:
if not os.geteuid() == 0:
sys.exit('Script must be run as root')
app = create_app(parse_options())
config_path = os.path.join('/', 'etc', 'blacklist', 'config.yml')
configuration = {}
if os.path.isfile(config_path):
with open(config_path) as f:
loaded_data = yaml.load(f)
if isinstance(loaded_data, dict):
configuration.update(loaded_data)
def required_input(text):
return input(text) or required_input(text)
def database_sqlite():
print('SQLite configuration:')
connection_info = urllib.parse.urlparse(
configuration.get('SQLALCHEMY_DATABASE_URI',
'sqlite:////home/blacklist/blacklist.db'))
if connection_info.scheme == 'sqlite':
database_path = connection_info.path
else:
database_path = '/home/blacklist/blacklist.db'
database_location = input(
'Location [{}]: '.format(database_path)) or database_path
app.config['SQLALCHEMY_DATABASE_URI'] = configuration[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///{}'.format(
database_location)
def database_mysql():
print('MySQL configuration:')
database_login('mysql')
def database_postgresql():
print('PostgreSQL configuration:')
database_login('postgresql')
def database_login(database_type):
connection_info = urllib.parse.urlparse(
configuration.get(
'SQLALCHEMY_DATABASE_URI',
'{}://blacklist:[email protected]/blacklist'.format(
database_type)))
if connection_info.scheme == database_type:
database_name = connection_info.path
database_server = connection_info.netloc
database_user = connection_info.username
database_password = connection_info.password
else:
database_name = 'blacklist'
database_server = '127.0.0.1'
database_user = '******'
database_password = None
database_server = input(
'Server [{}]: '.format(database_server)) or database_server
database_name = input(
'Database [{}]: '.format(database_name)) or database_name
database_user = input(
'User [{}]: '.format(database_user)) or database_user
if not database_password:
database_password = required_input('Password (required):')
else:
database_password = input('Password [{}]: '.format(
'*' * len(database_password))) or database_password
app.config['SQLALCHEMY_DATABASE_URI'] = configuration[
'SQLALCHEMY_DATABASE_URI'] = '{}://{}:{}@{}/{}'.format(
database_type, database_user, database_password,
database_server, database_name)
def ignore():
pass
database_types = {
0: {
'name': 'Ignore',
'default': True,
'call': ignore
},
1: {
'name': 'SQLite',
'default': False,
'call': database_sqlite
},
2: {
'name': 'PostgreSQL',
'default': False,
'call': database_postgresql
},
3: {
'name': 'MySQL',
'default': False,
'call': database_mysql
},
}
print('Choose database type you want to use:')
db_type_default = None
for db_type in database_types:
if database_types[db_type]['default']:
db_type_default = db_type
print('{}) {}{}'.format(
db_type, database_types[db_type]['name'],
' (default)' if database_types[db_type]['default'] else ''))
database_type = int(
input('Database type [{}]: '.format(db_type_default))
or db_type_default)
if database_type not in database_types:
print('Invalid option selected')
sys.exit(1)
database_types[database_type]['call']()
print('Webserver configuration:')
webserver_host = configuration.get('HOST', '127.0.0.1')
webserver_port = configuration.get('PORT', '80')
configuration['HOST'] = input(
'Host [{}]: '.format(webserver_host)) or webserver_host
configuration['PORT'] = input(
'Port [{}]: '.format(webserver_port)) or webserver_port
print('Save new configuration ?')
for item in configuration:
print('{}: {}'.format(item, configuration[item]))
save_configuration = input('Save ? (y/n) [y]: ') or 'y'
if save_configuration == 'y':
# Write new configuration
with open(config_path, 'w') as f:
yaml.dump(configuration,
f,
default_flow_style=False,
allow_unicode=True)
print('Configuration saved.')
recreate_database = input('Recreate database ? (y/n) [n]: ') or 'n'
if recreate_database == 'y':
# Create empty database
with app.app_context():
# Create tables
db.create_all()
# Stamp database to lates migration
stamp()
# Create roles
roles = {
Role.GUEST: 'Guest',
Role.ADMIN: 'Administrator',
Role.CUSTOMER: 'Customer',
Role.MAINTENANCE: 'Maintenance',
}
for role in roles:
found_role = Role.query.filter_by(id=role).first()
if not found_role:
found_role = Role()
found_role.id = role
found_role.name = roles[role]
db.session.add(found_role)
db.session.commit()
# Create admin user and set password
admin_username = '******'
admin = User.query.filter_by(username=admin_username).first()
new_password = random_password()
if not admin:
admin = User()
admin.set_password(new_password)
admin.username = admin_username
for role in Role.query.all():
admin.roles.append(role)
db.session.add(admin)
db.session.commit()
print('Database has been created, use this credentials to log-in:')
print('Username: {}'.format(admin_username))
print('Password: {}'.format(new_password))
restart_services = input(
'Restart services to load new configuration ? (y/n) [n]: ') or 'n'
if restart_services == 'y':
subprocess.call(['systemctl', 'restart', 'blacklist_celeryworker'])
subprocess.call(['systemctl', 'restart', 'blacklist_celerybeat'])
subprocess.call(['systemctl', 'restart', 'blacklist'])
def shell() -> None:
setup_logging('shell')
app = create_app(parse_options())
app.app_context().push()
Shell(make_context=lambda: dict(app=app, db=db)).run(no_ipython=False,
no_bpython=False)
"""
Bootstrap for use in uwsgi and so
"""
from blacklist.application import create_app, get_config
config = get_config('blacklist.config.Production')
app = create_app(config)