import argparse
import json
import os
import datetime
from simplecoin import create_manage_app, db, currencies, powerpools, redis_conn
from simplecoin.scheduler import SchedulerCommand
from simplecoin.models import (Transaction, UserSettings, Credit, ShareSlice,
DeviceSlice, Block, CreditExchange)
from urlparse import urlparse
from flask import current_app, _request_ctx_stack
from flask.ext.migrate import stamp
from flask.ext.script import Manager, Shell, Server
from flask.ext.migrate import MigrateCommand
manager = Manager(create_manage_app)
@manager.option('-e', '--emit', help='prints the SQL that is executed',
action="store_true")
def init_db(emit=False):
""" Resets entire database to empty state """
if emit:
import logging
logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
res = raw_input("You shouldn't probably ever do this in production! Are you"
" really, really sure you want to reset the DB {}? [y/n] "
.format(db.engine))
if res != "y":
return
else:
db.session.commit()
db.drop_all()
db.create_all()
stamp()
@manager.command
def list_donation_perc():
""" Gives a summary of number of users at each donation amount """
summ = {}
warn = False
for entry in UserSettings.query.all():
summ.setdefault(entry.pdonation_perc, 0)
summ[entry.pdonation_perc] += 1
if entry.pdonation_perc < 0:
warn = True
if warn:
print("WARNING: A user has set a donation percentage below 0!")
print "User fee summary"
print "\n".join(["{0:.2f}% donation from {1} users"
.format(k * 100, v) for k, v in sorted(summ.items())])
@manager.option("--currency", type=str, dest="currency", default=None)
@manager.option('stop_id', type=int)
@manager.option('start_id', type=int)
def del_payouts(start_id, stop_id, currency=None):
"""
Deletes payouts between start and stop id and removes their id from the
associated Credits.
Expects a start and stop payout id for payouts to be deleted
If currency is passed, only payout matching that currency will be removed
::Warning:: This can really fuck things up!
"""
from simplecoin.models import Payout
payouts = Payout.query.filter(Payout.id >= start_id,
Payout.id <= stop_id).all()
if currency is not None:
payouts = [payout for payout in payouts if payout.currency == currency]
pids = [payout.id for payout in payouts]
credits = Credit.query.filter(Credit.payout_id.in_(pids)).all()
for credit in credits:
credit.payout = None
if credit.block and credit.block.orphan:
credit.payable = False
db.session.flush()
for payout in payouts:
print "ID: {} ### USER: {} ### CREATED: {} ### AMOUNT: {} ### " \
"CREDIT_COUNT: {}".format(payout.id, payout.user,
payout.created_at, payout.amount,
payout.count)
db.session.delete(payout)
print "Preparing to delete {} Payouts.".format(len(pids))
res = raw_input("Are you really sure you want to delete these payouts? [y/n] ")
if res != "y":
db.session.rollback()
return
db.session.commit()
@manager.option("currency", type=str)
def update_trade_requests(currency):
"""
Looks at all uncompleted sell requests for a currency and
re-looks at their credits.
A Trade request's credits should always be payable - but this can
get messed up if there is a long chain of orphans that is only later
discovered (after the trade request is generated). This can happen from
a daemon being on the wrong fork for a while, and then switching to the
'official' fork.
It is important that this function be run AFTER running update_block_state
and del_payouts, which check the maturity of blocks & removes old incorrect
payouts
If any credits in the TR are discovered to now not be payable then subtract
that credit amount from the TR.
"""
from simplecoin.models import TradeRequest
trs = TradeRequest.query.filter_by(_status=0, currency=currency,
type="sell").all()
adjustment = {}
for tr in trs:
for credit in tr.credits[:]:
if credit.payable is False:
print "Found unpayable credit for {} {} on TR #{}".format(credit.amount, credit.currency, tr.id)
tr.quantity -= credit.amount
tr.credits.remove(credit)
adjustment.setdefault(tr.id, 0)
adjustment[tr.id] -= credit.amount
if adjustment:
print "Preparing to update TRs: {}.".format(adjustment)
else:
print "Nothing to update...exiting."
exit(0)
res = raw_input("Are you really sure you want to perform this update? [y/n] ")
if res != "y" and res != "yes":
db.session.rollback()
return
db.session.commit()
@manager.option('input', type=argparse.FileType('r'))
def import_shares(input):
for i, line in enumerate(input):
data = json.loads(line)
data['time'] = datetime.datetime.utcfromtimestamp(data['time'])
slc = ShareSlice(algo="scrypt", **data)
floored = DeviceSlice.floor_time(data['time'], data['span'])
if data['time'] != floored:
current_app.logger.warn("{} != {}".format(data['time'], floored))
data['time'] = floored
db.session.add(slc)
if i % 100 == 0:
print "{} completed".format(i)
db.session.commit()
@manager.option('input', type=argparse.FileType('r'))
def import_device_slices(input):
for i, row in enumerate(input):
data = json.loads(row)
data['time'] = datetime.datetime.utcfromtimestamp(data['time'])
data['stat'] = data.pop('_stat')
# Do a basic integrity check
floored = DeviceSlice.floor_time(data['time'], data['span'])
if data['time'] != floored:
current_app.logger.warn("{} != {}".format(data['time'], floored))
data['time'] = floored
db.session.add(DeviceSlice(**data))
# Print periodic progress
if i % 100 == 0:
db.session.commit()
print("{} inserted!".format(i))
@manager.command
def dump_effective_config():
import pprint
pprint.pprint(dict(current_app.config))
@manager.option('host')
def forward_coinservs(host):
""" Given a hostname, connects to a remote and tunnels all coinserver ports
to local ports. Useful for development testing. """
args = [host, "-N"]
for currency in currencies.itervalues():
if not currency.coinserv:
continue
args.append("-L {0}:127.0.0.1:{0}"
.format(currency.coinserv.config['port']))
for pp in powerpools.itervalues():
parts = urlparse(pp.monitor_address)
if parts.hostname not in ['localhost', '127.0.0.1']:
continue
args.append("-L {0}:127.0.0.1:{0}".format(parts.port))
current_app.logger.info(("/usr/bin/ssh", "/usr/bin/ssh", args))
os.execl("/usr/bin/ssh", "/usr/bin/ssh", *args)
@manager.option('-ds', '--dont-simulate', default=False,
action="store_true")
def convert_unexchangeable(dont_simulate):
""" Converts Credit exchanges for unexchangeable currencies to payout the
pool.
XXX: Now broken due to config refactor """
unexchangeable = []
for currency in currencies.itervalues():
# Skip unused currencies
if not currency.coinserv:
continue
if not currency.exchangeable:
unexchangeable.append((currency.key, currency.pool_payout))
current_app.logger.info("Looking for CreditExchange's for currencies {}"
.format(unexchangeable))
for key, pool_payout in unexchangeable:
blocks = {}
hashes = set()
for ce in (CreditExchange.query.join(CreditExchange.block, aliased=True).
filter_by(currency=key)):
blocks.setdefault(ce.block, [0, []])
hashes.add(ce.block.hash)
blocks[ce.block][0] += ce.amount
blocks[ce.block][1].append(ce)
db.session.delete(ce)
# Sanity check, make sure block objs as keys is valid
assert len(hashes) == len(blocks)
for block, (amount, credits) in blocks.iteritems():
# Create a new credit for the pool to displace the deleted
# CreditExchanges. It will always be a credit since the currency is
# unexchangeable
pool_block = Credit(
source=0,
address=pool_payout['address'],
user=pool_payout['user'],
currency=pool_payout['currency'].key,
amount=amount,
block_id=block.id,
payable=block.mature)
db.session.add(pool_block)
current_app.logger.info(
"Block {} status {} value {} removed {} CreditExchanges of {} total amount"
.format(block, block.status, block.total_value, len(credits), amount))
current_app.logger.info("For currency {}, updated {} blocks"
.format(key, len(blocks)))
if dont_simulate is True:
current_app.logger.info("Committing transaction!")
db.session.commit()
else:
current_app.logger.info("Rolling back!")
db.session.rollback()
@manager.option('-t', '--txid', dest='transaction_id')
def confirm_trans(transaction_id):
""" Manually confirms a transaction. Shouldn't be needed in normal use. """
trans = Transaction.query.filter_by(txid=transaction_id).first()
trans.confirmed = True
db.session.commit()
def make_context():
""" Setup a coinserver connection fot the shell context """
app = _request_ctx_stack.top.app
import simplecoin.models as m
return dict(app=app, currencies=currencies, powerpools=powerpools, m=m, db=db)
manager.add_command("shell", Shell(make_context=make_context))
manager.add_command("runserver", Server())
manager.add_command('db', MigrateCommand)
manager.add_command('scheduler', SchedulerCommand)
manager.add_option('-c', '--config', dest='configs', action='append',
type=argparse.FileType('r'))
manager.add_option('-l', '--log-level',
choices=['DEBUG', 'INFO', 'WARN', 'ERROR'], default='INFO')
if __name__ == "__main__":
manager.run()
