def get_options(self):
return [
Option('--email', '-e', dest='email', type=str),
Option('--password', '-p', dest='password', type=str),
Option('--fn', '-f', dest='fn', type=str),
Option('--ln', '-l', dest='ln', type=str),
Option('--admin', dest="admin", action="store_true")
]
def get_options(self):
return(
Option('site', default=None),
Option('rule', nargs='?', default=None),
Option('-m', '--module', dest="module", default=None,
help="Provide a module name if the module name differs from"
" the site name."),
)
def get_options (self):
return [
Option ('-l', '--compress-level', dest='level', default=9,
choices=range (1, 10), type=int),
Option ('-f', '--force', dest='force', action='store_true',
default=False, help='Overrides existing compressed asset')
]
class Analyze(Command):
""" (Re)analyze 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):
if force:
# invalidate all results
db.session.query(Flight).update({'needs_analysis': True})
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)))
else:
self.incremental(self.do, q.filter(Flight.needs_analysis == True))
def do(self, flight):
print flight.id
return analyse_flight(flight)
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
class Sources(Command):
"""
Defines a set of actions to take against Lemur's sources.
"""
option_list = (Option('-s',
'--sources',
dest='sources',
action='append',
help='Sources to operate on.'),
Option('-a',
'--action',
choices=['sync', 'clean'],
dest='action',
help='Action to take on source.'))
def run(self, sources, action):
if not sources:
table = []
for source in source_service.get_all():
table.append([source.label, source.active, source.description])
sys.stdout.write(
tabulate(table, headers=['Label', 'Active', 'Description']))
sys.exit(1)
for label in sources:
source = source_service.get_by_label(label)
if not source:
sys.stderr.write(
"Unable to find specified source with label: {0}".format(
label))
if action == 'sync':
self.sync(source)
if action == 'clean':
self.clean(source)
@staticmethod
def sync(source):
start_time = time.time()
sys.stdout.write("[+] Staring to sync source: {label}!\n".format(
label=source.label))
source_service.sync(source)
sys.stdout.write(
"[+] Finished syncing source: {label}. Run Time: {time}\n".format(
label=source.label, time=(time.time() - start_time)))
@staticmethod
def clean(source):
start_time = time.time()
sys.stdout.write("[+] Staring to clean source: {label}!\n".format(
label=source.label))
source_service.clean(source)
sys.stdout.write(
"[+] Finished cleaning source: {label}. Run Time: {time}\n".format(
label=source.label, time=(time.time() - start_time)))
def get_options(self):
return [
Option('--with-coverage', '-c', dest='use_coverage', action='store_true',
help='Use coverage?', default=self.use_coverage),
Option('--no-capture', '-s', dest='no_capture', action='store_true',
default=self.no_capture),
Option('--verbose', '-v', dest='verbose', action='store_true',
default=self.verbose)
]
def get_options(self):
return [
Option('-b64', '--base64', dest='base64', action='store_true'),
Option('-a',
'--address',
dest='address',
default='tcp://localhost:8181'),
]
def get_options(self):
return [
Option('--name', dest='name', required=True),
Option('--name-display', dest='name_display', required=True),
Option('--restrict-countries',
dest='restrict_countries',
required=True),
Option('--db', dest='db', required=True)
]
class ImportCFP(Command):
option_list = [
Option('-f',
'--file',
dest='filename',
help='The .csv file to load',
default='tests/2014_proposals.csv'),
Option('-s',
'--state',
dest='state',
default='locked',
help='The state to import the proposals as')
]
def run(self, filename, state):
faker = Faker()
with open(filename) as csvfile:
# id, title, description, length, need_finance,
# one_day, type, experience, attendees, size
reader = DictReader(csvfile)
count = 0
for row in reader:
if Proposal.query.filter_by(title=row['title']).first():
continue
user = User('*****@*****.**' % count, faker.name())
db.session.add(user)
proposal = TalkProposal() if row['type'] == u'talk' else\
WorkshopProposal() if row['type'] == u'workshop' else\
InstallationProposal()
proposal.state = state
proposal.title = row['title']
proposal.description = row['description']
proposal.one_day = True if row.get('one_day') == 't' else False
proposal.needs_money = True if row.get(
'need_finance') == 't' else False
if row['type'] == 'talk':
proposal.length = row['length']
elif row['type'] == 'workshop':
proposal.length = row['length']
proposal.attendees = row['attendees']
else:
proposal.size = row['size']
proposal.user = user
db.session.add(proposal)
db.session.commit()
count += 1
app.logger.info('Imported %s proposals' % count)
def get_options(self):
return [
Option('-a',
'--addroles',
dest='addroles',
action="store_true",
default=True),
Option('-r', '--revision', dest='revision', default='head'),
]
class ProcessIpfsAddOutput(Command):
"""
Store the hashes from the output of "ipfs add -r" in the Upload records.
When a dumpfile is given it dumps all the hashes (one per line) into a file
"""
option_list = (
Option(dest='filename'),
Option('--dump', '-d', dest='dumpfile'),
)
def run(self, filename, dumpfile=None):
if not os.path.exists(filename):
print(u"ERROR: file doesn't exist: %s" % (filename, ))
return
with open(filename) as f:
if dumpfile:
with open(dumpfile, 'w') as fo:
for line in f:
self.dump_line(line, fo)
else:
for line in f:
self.process_line(line)
def dump_line(self, line, f):
line = line.strip()
pieces = line.split(" ", 2)
if pieces[0] == "added":
hash = pieces[1]
f.write("%s\n" % hash)
def process_line(self, line):
line = line.strip()
pieces = line.split(" ", 2)
if pieces[0] == "added":
hash = pieces[1]
path = pieces[2]
full_path = os.path.join(app.config.get('UPLOADS_DIR'), path)
if os.path.isfile(full_path):
u = None
try:
results = Upload.objects.filter(file_path=path,
ipfs=None)
if results:
u = results[0]
except Upload.DoesNotExist, e:
print(
u"WARNING: Couldn't find Upload model object for path=%s"
% (path, ))
if u:
print(u"Updating %s %s with hash %s" %
(u.id, u.file_path, hash))
u.ipfs = hash
u.save()
else:
def get_options(self):
return(
Option('site', default=None),
Option('rule', default=None),
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),
)
def get_options(self):
return [
Option('-h', '--host', dest='host', default=self.host),
Option('-p', '--port', dest='port', type=int, default=self.port),
Option('-w',
'--workers',
dest='workers',
type=int,
default=self.workers),
]
def get_options(self):
return [
Option('-n', '--number', dest='number', default=1, type=int),
Option('-m', '--message', dest='message', default='PING'),
Option('-a',
'--address',
dest='address',
default='tcp://localhost:8080'),
]
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))
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
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('-u',
'--username',
dest='username',
default=self.default_username),
Option('-p',
'--password',
dest='password',
default=self.default_password),
]
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,
])
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('-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']),
]
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 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 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('-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']),
]
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='?'),
)
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')
]
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)
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'),
]
