def get_options(self):
return [
Option('-u',
'--username',
dest='username',
default=self.default_username),
Option('-p',
'--password',
dest='password',
default=self.default_password),
]
class RunServer(Command):
option_list = (
Option('--port', '-p', dest='port'),
Option('--hostname', '-hn', dest='host'),
)
def run(self, host="127.0.0.1", port=5000):
if port is None:
port = 5000
port = int(port)
app.run(debug=current_app.config['DEBUG'], host=host, port=port)
class CreateRoleCommand(Command):
"""Create a role"""
option_list = (
Option('-n', '--name', dest='name', default=None),
Option('-d', '--desc', dest='description', default=None),
)
def run(self, **kwargs):
user_datastore.create_role(**kwargs)
print 'Role "%(name)s" created successfully.' % kwargs
def get_options(self):
return (
Option('-b', '--bind',
dest='address',
type=str,
default=self.address),
Option('-w', '--workers',
dest='workers',
type=int,
default=self.workers),
)
def get_options(self):
return [
Option('--verbosity',
'-v',
dest='verbose',
type=int,
default=self.verbosity),
Option('--failfast',
dest='failfast',
default=self.failfast,
action='store_false')
]
def get_options(self):
return (Option('-t',
'--tests',
dest='tests',
default=None,
help="specifies unittests to run"),
Option('-c',
'--coverage',
dest='coverage',
default=None,
action='store_true',
help="runs API part unittest with coverage"))
def get_options(self):
return(
Option('site', default=None),
Option('rule', nargs='?', default=None),
Option('-c', '--context', action='store_true',
dest="show_context"),
Option('-m', '--module', dest="module", default=None,
help="Provide a module name if the module name differs from"
" the site name."),
Option('--data', dest="data_only", action="store_true",
help=argparse.SUPPRESS),
)
class Worker(Command):
option_list = (
Option('-c', '--concurrency', dest='concurrency', default='1'),
Option('-l', '--loglevel', dest='loglevel', default='debug'),
)
def run(self, concurrency, loglevel):
celery.start(argv=['worker.py', 'worker',
'--concurrency', concurrency,
'--loglevel', loglevel,
])
class DatabasePolicy(Command):
"""
配置同步数据的策略
- policy_log [database] [table] 创建同步需要的日志表需要的表结构与触发器
"""
option_list = (
Option("-d", "--debug", dest='debug_flag', action="count", required=False, default=0,
help='debug flag'),
Option(metavar='cmd', dest='cmd', help='action, in [policy_log]'),
Option(metavar='dbname', dest='db_name', help='database to be sync'),
Option(metavar='tblname', dest='tbl_name', help='table name', nargs='?'),
)
class WorkerCommand(RQCommand):
"Starts an RQ worker."
option_list = (
Option('--burst',
'-b',
action='store_true',
help='Run in burst mode (quit after all work is done)'),
Option('--name', '-n', help='Specify a different name'),
Option('--path', '-P', default='.', help='Specify the import path.'),
Option('--results-ttl',
type=int,
help='Default results timeout to be used'),
Option('--worker-ttl',
type=int,
help='Default worker timeout to be used'),
Option('--verbose', '-v', action='store_true',
help='Show more output'),
Option('--quiet', '-q', action='store_true', help='Show less output'),
Option('--exception-handler',
type=list,
help='Exception handler(s) to use',
action='append'),
Option('--pid',
metavar='FILE',
help='Write the process ID number '
'to a file at the specified path'),
Option('queues',
nargs='*',
metavar='QUEUE',
help='Queues to work with, defaults to the ones specified '
'in the Flask app config'))
def run(self, burst, name, path, results_ttl, worker_ttl, verbose, quiet,
exception_handler, pid, queues):
cli.worker.callback(
url=self.rq.url,
config=None,
burst=burst,
name=name,
worker_class=self.rq.app_worker_path,
job_class=self.rq.app_job_path,
queue_class=self.rq.app_queue_path,
path=path,
results_ttl=results_ttl,
worker_ttl=worker_ttl,
verbose=verbose,
quiet=quiet,
sentry_dsn=None,
exception_handler=exception_handler or self.rq._exception_handlers,
pid=pid,
queues=queues or self.rq.queues,
)
def get_options(self):
return [
Option('-pfa',
'--ping-frontend-address',
dest='ping-frontend-address',
default=app.config['PING_QUEUE_ADDRESS']),
Option('-pba',
'--ping-backend-address',
dest='ping-backend-address',
default=app.config['PING_QUEUE_BACKEND_ADDRESS']),
]
def get_options(self):
return [
Option('-dfa',
'--data-frontend-address',
dest='data-frontend-address',
default=app.config['DATA_QUEUE_ADDRESS']),
Option('-dba',
'--data-backend-address',
dest='data-backend-address',
default=app.config['DATA_QUEUE_BACKEND_ADDRESS']),
]
def get_options(self):
return [
Option('-f',
'--frontend-address',
dest='frontend-address',
default='tcp://*:8080'),
Option('-b',
'--backend-address',
dest='backend-address',
default='tcp://*:8181'),
]
class Merge(Command):
""" Merge two user accounts """
option_list = (
Option('new_id', type=int, help='ID of the new user account'),
Option('old_id', type=int, help='ID of the old user account'),
)
def run(self, new_id, old_id):
new = db.session.query(User).get(new_id)
if not new:
print >> sys.stderr, "No such user: %d" % new_id
old = db.session.query(User).get(old_id)
if not old:
print >> sys.stderr, "No such user: %d" % old_id
if old.club != new.club:
print >> sys.stderr, "Different club;", old.club, new.club
sys.exit(1)
db.session.query(Club).filter_by(owner_id=old_id).update(
{'owner_id': new_id})
db.session.query(IGCFile).filter_by(owner_id=old_id).update(
{'owner_id': new_id})
db.session.query(Flight).filter_by(pilot_id=old_id).update(
{'pilot_id': new_id})
db.session.query(Flight).filter_by(co_pilot_id=old_id).update(
{'co_pilot_id': new_id})
db.session.query(TrackingFix).filter_by(pilot_id=old_id).update(
{'pilot_id': new_id})
db.session.flush()
db.session.commit()
new = db.session.query(User).get(new_id)
old = db.session.query(User).get(old_id)
assert new and old
db.session.delete(old)
db.session.flush()
if new.email_address is None and old.email_address is not None:
new.email_address = old.email_address
if new._password is None and old._password is not None:
new._password = old._password
# TODO: merge display name or not?
if old.tracking_key is not None:
new.tracking_key = old.tracking_key
db.session.commit()
class DatabaseIndex(Command):
"""
创建索引
- [channel_name] @meta 全部重建
- [channel_name] @worker 只重建该worker上的
"""
option_list = (
Option("-d", "--debug", dest='debug_flag', action="count", required=False, default=0,
help='debug flag'),
Option(metavar='channel', dest='channel_name', help='index channel to be build.'),
Option(metavar='tblname', dest='tbl_name', help='table name', nargs='?'),
)
class UpdateCommand(Command):
option_list = (
Option("-s", "--since", dest="since", required=False),
Option("-p", "--pattern", dest="pattern", required=False),
)
def run(self, since, pattern):
files = None
if pattern is not None:
files = glob.glob(pattern)
update(files=files, since=since)
class FindMeetings(Command):
""" Find meetings points between flights """
option_list = (
Option('--force',
action='store_true',
help='re-analyse all flights, not just the scheduled ones'),
Option('ids',
metavar='ID',
nargs='*',
type=int,
help='Any number of flight IDs.'),
)
def run(self, force, ids):
q = db.session.query(Flight)
q = q.order_by(Flight.id)
if ids:
self.apply_and_commit(self.do, q.filter(Flight.id.in_(ids)))
elif force:
self.incremental(self.do, q)
def do(self, flight):
print flight.id
tasks.find_meetings(flight.id)
return True
def apply_and_commit(self, func, q):
n_success, n_failed = 0, 0
for record in q:
if func(record):
n_success += 1
else:
n_failed += 1
if n_success > 0:
print "commit"
db.session.commit()
return n_success, n_failed
def incremental(self, func, q):
"""Repeatedly query 10 records and invoke the callback, commit
after each chunk."""
n = 10
offset = 0
while True:
n_success, n_failed = self.apply_and_commit(
func,
q.offset(offset).limit(n))
if n_success == 0 and n_failed == 0:
break
offset += n_failed + n_success
def get_options(self):
return (
Option('-t', '--host', dest='host', default=self.host),
Option('-p', '--port', dest='port', type=int, default=self.port),
Option('--profile',
action='store_true',
dest='profile',
default=self.profile),
Option('--profile-max',
type=int,
dest='profile_max',
default=self.profile_max),
)
class Run(Command):
"""Run the server in debug mode"""
option_list = (
Option('--host', '-o', dest='host', default='localhost'),
Option('--port', '-p', dest='port', default=5000),
)
def run(self, host, port):
app = api.create_app()
app.wsgi_app = reverseproxied.ReverseProxied(app.wsgi_app)
app.run(host=host, port=port, debug=True, use_debugger=False)
class ResetUserCommand(Command):
option_list = (
Option('-e', '--email', dest='email', default=None),
Option('-p', '--password', dest='password', default=None),
)
def run(self, **kwargs):
try:
pwd = encrypt_password(kwargs['password'])
User.objects(email=kwargs['email']).first().update(
set__password=pwd)
except Exception, e:
print('Error resetting user password: %s' % e)
class WaitForNodes(Command):
"""Wait for nodes to become ready.
"""
option_list = (
Option('--nodes', dest='nodes', required=True),
Option('--timeout', dest='timeout', required=False, type=int),
Option('--verbose', dest='verbose', required=False,
action='store_true'),
)
def run(self, nodes, timeout, verbose):
nodes_list = nodes.split(',')
wait_for_nodes(nodes_list, timeout, verbose)
class RunTests(Command):
"Run unit-tests"
option_list = (
Option('--verbose', '-v', action='store_true', default=False),
Option('--failfast', '-f', action='store_true', default=False),
)
def run(self, verbose, failfast):
import unittest
import test_ffdnispdb
test = unittest.defaultTestLoader.loadTestsFromModule(test_ffdnispdb)
unittest.TextTestRunner(verbosity=2 if verbose else 1,
failfast=bool(failfast)).run(test)
class SetPassword(Command):
option_list = (
Option('--id', '-i', dest='id'),
Option('--password', '-p', dest='pw'),
)
def run(self, id, pw):
if '@' in id:
u = User.objects.get(email=id)
else:
u = User.objects.get(id=id)
u.password = encrypt_password(pw)
u.save()
class Create_User(Command):
description = 'This command allows you to create a user account'
option_list = (
Option('--name',
'-n',
required=True,
dest='name',
type=unicode,
help="Set the wiki user name to NAME."),
Option(
'--display_name',
'-d',
required=False,
dest="display_name",
type=unicode,
help=
"Set the wiki user's display name to DISPLAY_NAME (e.g. in case the NAME is cryptic)."
),
Option('--email',
'-e',
required=True,
dest='email',
type=unicode,
help="Set the user's email address to EMAIL."),
Option('--openid',
'-o',
required=False,
dest='openid',
type=unicode,
help="Set the user's openid address."),
Option('--password',
'-p',
required=True,
dest="password",
type=unicode,
help="Set the user's password to PASSWORD."),
)
def run(self, name, display_name, email, openid, password):
before_wiki()
msg = user.create_user(username=name,
password=password,
email=email,
openid=openid)
if msg:
print msg
else:
u = user.User(auth_username=name)
print " %-20s %-25s %-35s - created." % (u.itemid, u.name,
u.email),
class UserCommand(Command):
'''Creates a new user'''
option_list = (
Option('--name', dest='name', help='create user with nickname NAME'),
Option('--password',
dest='password',
help='create user with password PASSWORD'),
Option(
'--is-admin',
action='store_true',
dest='admin',
help='create user as admin (only works in non-interactive mode)'),
Option('--no-interactive',
action='store_true',
dest='non_interactive',
help='non-interactive mode (no questions asked)'),
)
def run(self,
name=None,
password=None,
admin=False,
non_interactive=False):
if name is None and not non_interactive:
name = input('Nickname: ')
if password is None and not non_interactive:
password = input('Password: '******'Create as administrator? [Y/N] ')
if admin_input == 'Y' or admin_input == 'y':
admin = True
elif admin_input == 'N' or admin_input == 'n':
admin = False
else:
print('Error: Unrecognized input. Aborting.')
return 1
if name is None or password is None:
print('Error: Missing keys. Aborting.')
return 1
user = User(nickname=name, is_admin=admin)
db.session.add(user)
db.session.commit()
h = Hash(user_id=user.id, passwd_hash=create_hash(password))
db.session.add(h)
db.session.commit()
return 0
class UpdateFlightPaths(Command):
""" Update Skylines flight paths """
option_list = (
Option('--force', action='store_true',
help='re-analyse all flights, not just the scheduled ones'),
Option('ids', metavar='ID', nargs='*', type=int,
help='Any number of flight IDs.'),
)
def run(self, force, ids):
q = db.session.query(Flight)
q = q.options(joinedload(Flight.igc_file))
q = q.order_by(Flight.id)
if ids:
self.apply_and_commit(self.do, q.filter(Flight.id.in_(ids)))
elif force:
self.incremental(self.do, q)
else:
self.incremental(self.do, q.filter(
or_(Flight.locations == None, Flight.timestamps == None)))
def do(self, flight):
print flight.id
return flight.update_flight_path()
def apply_and_commit(self, func, q):
n_success, n_failed = 0, 0
for record in q:
if func(record):
n_success += 1
else:
n_failed += 1
if n_success > 0:
print "commit"
db.session.commit()
return n_success, n_failed
def incremental(self, func, q):
"""Repeatedly query 10 records and invoke the callback, commit
after each chunk."""
n = 10
offset = 0
while True:
n_success, n_failed = self.apply_and_commit(
func, q.offset(offset).limit(n))
if n_success == 0 and n_failed == 0:
break
offset += n_failed + n_success
def get_options(self):
return [
Option('-a',
'--addroles',
dest='addroles',
action="store_true",
default=True),
Option('-d',
'--default',
dest='default',
action="store_true",
default=False),
Option('-r', '--revision', dest='revision', default='head'),
]
class Billing(Command):
"Generate and send firm account"
option_list = (
Option('--firm_id', dest='firm_id'),
Option('--date', dest='date', help='Format yyyy-mm-dd'),
Option('--send', dest='send', default=False),
)
def run(self, firm_id, date, send):
firm_id = int(firm_id)
date = datetime.strptime(date, '%Y-%m-%d')
print AccountSenderTask.account_generate(firm_id, date, send)
class NodeManager(Command):
option_list = [
Option('--hostname', dest='hostname', required=True),
Option('--kube-type', dest='kube_type', required=False),
Option('--do-deploy', dest='do_deploy', action='store_true'),
Option('--wait', dest='wait', action='store_true'),
Option('--timeout', dest='timeout', required=False, type=int),
Option('-t', '--testing', dest='testing', action='store_true'),
Option('--docker-options', dest='docker_options'),
Option('--ebs-volume', dest='ebs_volume', required=False),
Option('--localstorage-device', dest='ls_device', default=(),
required=False),
Option('-v', '--verbose', dest='verbose', required=False,
action='store_true'),
]
def run(self, hostname, kube_type, do_deploy, wait, timeout, testing,
docker_options, ebs_volume, ls_device, verbose):
if kube_type is None:
kube_type_id = Kube.get_default_kube_type()
else:
kube_type = Kube.get_by_name(kube_type)
if kube_type is None:
raise InvalidCommand('Kube type with name `{0}` not '
'found.'.format(kube_type))
kube_type_id = kube_type.id
options = None
testing = testing or WITH_TESTING
if docker_options is not None:
options = {'DOCKER': docker_options}
if get_maintenance():
raise InvalidCommand(
'Kuberdock is in maintenance mode. Operation canceled'
)
try:
check_node_data({'hostname': hostname, 'kube_type': kube_type_id})
if not isinstance(ls_device, (tuple, list)):
ls_device = (ls_device,)
res = create_node(None, hostname, kube_type_id, do_deploy, testing,
options=options,
ls_devices=ls_device, ebs_volume=ebs_volume)
print(res.to_dict())
if wait:
wait_for_nodes([hostname, ], timeout, verbose)
except Exception as e:
raise InvalidCommand("Node management error: {0}".format(e))
class Deliver(Command):
option_list = [
Option('--user', '-u', dest='user'),
Option('--recipient', '-r', dest='recipient'),
Option('--sender', '-s', dest='sender'),
]
def run(self, user, recipient, sender):
app.logger.info("new message by user '%s' from '%s' to '%s'", user, sender, recipient)
input = sys.stdin.read()
filename = hashlib.sha1(input).hexdigest() + '.eml'
fs.setcontents(filename, input)
save_email.delay(user, sender, recipient, filename)
