def get_karp_subtypes(mode):
""" Ask Karp about all available subtypes """
logging.debug(' * Searching!')
url = settings.karp + '/statlist?%s'
size = settings.get('overflowsize', 1000)
params = {
'resource': settings.get('resource', mode),
'mode': settings.get('mode', mode),
'size': size,
'buckets': 'subtype'
}
params['q'] = build_query('', '', False, settings.get('sourcelanguage'),
mode)
data = urllib.parse.urlencode(params)
logging.debug('data %s', params)
full_url = url % data
logging.debug(str(full_url))
req = urllib.request.Request(full_url)
add_credentials(req, mode)
response = urllib.request.urlopen(req)
data = json.loads(response.read().decode())
res = set()
for subtype in data['stat_table']:
if subtype[0]:
res.add(subtype[0])
return res
def build_query(word, subtypes, contains, lang, mode):
""" Construct the query string to Karp """
wordfield = settings.get('baseform.search', mode)
if lang != settings.get('sourcelanguage', mode):
wordfield = settings.get('targetform.search', mode)
if word and contains:
word = word.lower()
word_q = 'extended||and|{}|regexp|.*{}.*'.format(wordfield, word)
elif word:
word = word.lower()
op = 'startswith'
if contains:
word = '.*{}.*'.format(word)
op = 'regexp'
word_q = 'extended||and|{}|{}|{}'.format(wordfield, op, word)
else:
word_q = 'extended||and|{}|regexp|.*'.format(wordfield)
# TODO check status? f'||and|termstatus.bucket|exists' #equals|{settings.ok_status}'
if subtypes:
subtype = '|'.join(subtypes)
query = '{}||and|subtype.search|equals|{}'.format(word_q, subtype)
else:
query = word_q
return query
def add_credentials(request, mode):
""" Prepare a request by adding login credentials """
credentials = (
'%s:%s' %
(settings.get('username', mode), settings.get('password', mode)))
encoded_credentials = base64.b64encode(credentials.encode('ascii'))
request.add_header('Authorization',
'Basic %s' % encoded_credentials.decode("ascii"))
def main():
server = Server()
application = service.Application(settings.get('PROJECT_NAME'))
logfile = DailyLogFile(settings.get('LOG_FILE'), settings.get('LOG_DIR'))
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
server.setServiceParent(application)
from twisted.internet import reactor
reactor.suggestThreadPoolSize(10)
def limit_query(subtypes, lang, mode):
url = settings.karp + '/query?%s'
params = {
'resource': settings.get('resource', mode),
'mode': settings.get('mode', mode),
'size': 0
}
params['q'] = build_query('', subtypes, False, lang, mode)
data = make_call(url, params, mode)
if int(data['hits']['total']) > settings.get('overflowsize'):
return settings.get_first_letter(lang, mode)
return ''
def authenticate(self, mode):
""" Authenticate to Karp. """
try:
auth_header = self.request.headers.get('Authorization')
basic = auth_header[6:]
url = settings.karp + '/checkuser'
req = urllib.request.Request(url)
req.add_header('Authorization', 'Basic %s' % basic)
response = json.loads(
urllib.request.urlopen(req).read().decode('utf8'))
ok = response["authenticated"]
except:
ok = False
if not ok:
logging.debug('Bad username or password?')
error = errors.AuthenticationError("Bad username or password?")
self.return_error(error)
raise error
else:
resources = response.get("permitted_resources",
{}).get("lexica", {})
lexok = settings.get('resource', mode) in resources
if not lexok:
logging.debug('Cannot edit resource %s', resources)
error = errors.AuthenticationError(
"You are not allowed to edit the resource")
self.return_error(error)
async def test_get_presigned_tx_xdr_from_request_when_dont_have_payload(
self, mock_get_transaction, mock_get_wallet):
escrow_address = "GAH6333FKTNQGSFSDLCANJIE52N7IGMS7DUIWR6JIMQZE7XKWEQLJQAY"
mock_get_transaction.return_value = {}
host = settings.get('HOST', None)
mock_get_wallet.return_value = {
'@id':
reverse('escrow-address', escrow_address=''),
'asset': {
'HOT': '10.0000000',
'XLM': '9.9999200'
},
'generate-wallet':
reverse(
'escrow-generate-wallet',
escrow_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD'),
'data': {
'destination_address':
'GABEAFZ7POCHDY4YCQMRAGVVXEEO4XWYKBY4LMHHJRHTC4MZQBWS6NL6',
'cost_per_transaction': '5'
}
}
resp = await self.client.request(
"POST",
reverse('generate-presigned-transactions',
escrow_address=escrow_address))
assert resp.status == 400
def run(self, host=None, port=None, autoreload=None, debug=False):
"""Runs the application on a local development server.
Args:
host: the hostname to listen on. Defaults to ``'127.0.0.1'``.
port: the port of the webserver. Defaults to ``5100`` or the
port defined in the ``SERVER_NAME`` config variable if
present.
"""
from wsgiref.simple_server import make_server
if debug: settings.DEBUG = True
self.autoreload = autoreload
if host is None:
host = '127.0.0.1'
if port is None:
server_name = settings.get('SERVER_NAME')
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
else:
port = 5100
logging.info('application (%s) will start at %s:%s' % (self.document_root, host, port))
server = None
def runner():
server = make_server(host, port, self)
server.serve_forever()
def stopper():
if server:
server.shutdown()
server.close()
if autoreload:
run_with_reloader(runner, stopper=stopper)
else:
runner()
async def test_get_wallet_success_not_trust_hot(mock_address):
balances = [{'balance': '9.9999200', 'asset_type': 'native'}]
mock_address.return_value = StellarWallet(balances)
result = await get_wallet_detail(
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')
host = host = settings.get('HOST', None)
url = reverse('wallet-address',
wallet_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')
expect_data = {
'wallet_address':
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD',
'@id': f'{host}{url}',
'trust':
f"{settings['HOST']}{reverse('change-trust-add-token', wallet_address='GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')}",
'asset': {
'XLM': '9.9999200'
},
'sequence': '1',
'data': {
'age': '30',
'name': 'UnitTest'
},
}
assert result == expect_data
def get(self, *args):
mode = self.get_query_argument('mode', settings.get('mode'))
self.authenticate(mode)
subtype = args[0]
existing = set(get_subtypes(mode))
if subtype not in existing:
existing.add(subtype)
update_subtypes(existing, mode)
subtypes = get_subtypes(mode)
self.write({'subtype': subtype, 'publish': True, 'subtypes': subtypes})
def make_application():
ssetings = settings.get('SERVER')
port = ssetings['port']
seed_servie = MemoryBasedSeedsService()
handler = SchedulerHandler(seed_servie)
processor = Scheduler.Processor(handler)
factory = TTwisted.ThriftServerFactory(processor,
TBinaryProtocol.TBinaryProtocolFactory())
tcp_service = internet.TCPServer(port, factory)
application = service.Application(ssetings['name'])
logfile = DailyLogFile(settings.get('LOG_FILE'), settings.get('LOG_DIR'))
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
multiService = service.MultiService()
tcp_service.setServiceParent(multiService)
multiService.setServiceParent(application)
return application
def get(self):
unpublished = self.get_query_argument('unpublished', False)
mode = self.get_query_argument('mode', settings.get('mode'))
subtypes = get_subtypes(mode)
logging.debug(' * Subtypes %s' % subtypes)
if unpublished in [True, "true", "True"]:
all_subtypes = get_karp_subtypes(mode)
unpub_subtypes = list(all_subtypes.difference(subtypes))
self.write({'published': subtypes, 'unpublished': unpub_subtypes})
else:
self.write({'subtypes': subtypes})
def make_application():
ssetings = settings.get('SERVER')
port = ssetings['port']
pkg_size = settings.getint("SEED_PKG_SIZE")
seed_servie = MemoryBasedSeedsService(pkg_size)
handler = RequestHandler(seed_servie)
processor = Scheduler.Processor(handler)
factory = TTwisted.ThriftServerFactory(processor,
TBinaryProtocol.TBinaryProtocolFactory())
tcp_service = internet.TCPServer(port, factory)
application = service.Application(ssetings['name'])
logfile = DailyLogFile(settings.get('LOG_FILE'), settings.get('LOG_DIR'))
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
multiService = service.MultiService()
tcp_service.setServiceParent(multiService)
multiService.setServiceParent(application)
return application
def loadallmodules(self):
enabled_modules = settings.get('modules') or []
for module in enabled_modules:
try:
mod = importlib.import_module(defaults.MODULES_NAME + module + defaults._SETTINGS)
uri = getattr(mod, 'uri', '')
operations = getattr(mod, 'operations', [])
self.adduri(uri, operations)
except ImportError:
raise
def prepare(self):
""" Set up file system """
try:
for mode in settings.get_modes():
if mode == 'default':
continue
typefile = settings.get('subtypes', mode)
directory = os.path.dirname(typefile)
# TODO this only works for paths like a/b.txt, not b.txt och a/b/c.txt
if not os.path.isdir(directory):
os.mkdir(directory)
if not os.path.isfile(typefile):
open(typefile, 'w').write('')
except errors.ConfigurationError as error:
self.return_error(error)
async def test_get_wallet_success_trusted_hot(mock_address):
balances = [
{
'balance': '7.0000000',
'limit': '922337203685.4775807',
'asset_type': 'credit_alphanum4',
'asset_code': settings['ASSET_CODE'],
'asset_issuer': settings['ISSUER'],
},
{
'balance': '10.0000000',
'limit': '1000',
'asset_type': 'credit_alphanum4',
'asset_code': 'HTKN',
'asset_issuer': settings['ISSUER'],
},
{
'balance': '9.9999200',
'asset_type': 'native'
},
]
mock_address.return_value = StellarWallet(balances)
result = await get_wallet_detail(
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')
host = settings.get('HOST', None)
url = reverse('wallet-address',
wallet_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')
expect_data = {
'wallet_address':
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD',
'@id': f'{host}{url}',
'asset': {
settings['ASSET_CODE']: '7.0000000',
'XLM': '9.9999200'
},
'sequence': '1',
'data': {
'age': '30',
'name': 'UnitTest'
},
}
assert result == expect_data
async def test_get_presigned_tx_xdr_from_request(self,
mock_get_transaction,
mock_get_wallet):
escrow_address = "GAH6333FKTNQGSFSDLCANJIE52N7IGMS7DUIWR6JIMQZE7XKWEQLJQAY"
transaction_source_address = "GDSB3JZDYKLYKWZ6NXDPPGPCYJ32ISMTZ2LVF5PYQGY4B4FGNIU2M5BJ"
mock_get_transaction.return_value = {}
host = settings.get('HOST', None)
mock_get_wallet.return_value = {
'@id':
reverse('escrow-address', escrow_address=''),
'asset': {
'HOT': '10.0000000',
'XLM': '9.9999200'
},
'generate-wallet':
reverse(
'escrow-generate-wallet',
escrow_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD'),
'data': {
'destination_address':
'GABEAFZ7POCHDY4YCQMRAGVVXEEO4XWYKBY4LMHHJRHTC4MZQBWS6NL6',
'cost_per_transaction': '5'
}
}
resp = await self.client.request(
"POST",
reverse('generate-presigned-transactions',
escrow_address=escrow_address),
json={'transaction_source_address': transaction_source_address})
assert resp.status == 200
mock_get_wallet.assert_called_once_with(escrow_address)
destination_address = "GABEAFZ7POCHDY4YCQMRAGVVXEEO4XWYKBY4LMHHJRHTC4MZQBWS6NL6"
balance = Decimal("10.0000000")
cost_per_tx = Decimal("5")
mock_get_transaction.assert_called_once_with(
escrow_address, transaction_source_address, destination_address,
balance, cost_per_tx)
async def test_get_presigned_tx_xdr_cannot_get_value_in_data(
self, mock_get_transaction, mock_get_wallet):
host = settings.get('HOST', None)
escrow_address = "GAH6333FKTNQGSFSDLCANJIE52N7IGMS7DUIWR6JIMQZE7XKWEQLJQAY"
transaction_source_address = "GDSB3JZDYKLYKWZ6NXDPPGPCYJ32ISMTZ2LVF5PYQGY4B4FGNIU2M5BJ"
mock_get_transaction.return_value = {}
mock_get_wallet.return_value = {
'@id':
reverse(
'escrow-address',
escrow_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD'),
'asset': {
'HOT': '10.0000000',
'XLM': '9.9999200'
},
'generate-wallet':
reverse(
'escrow-generate-wallet',
escrow_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD'),
'data': {
'source':
'GABEAFZ7POCHDY4YCQMRAGVVXEEO4XWYKBY4LMHHJRHTC4MZQBWS6NL6'
}
}
resp = await self.client.request(
"POST",
reverse('generate-presigned-transactions',
escrow_address=escrow_address),
json={'transaction_source_address': transaction_source_address})
error_message = await resp.json()
error_message = error_message['message']
assert error_message == "Parameter 'destination_address' not found. Please ensure parameters is valid."
def createengine():
dbconf = settings.get('database')
if dbconf is None:
print 'Database information not found, using in-memory database.'
return create_engine('sqlite:///:memory:')
else:
encoding = dbconf['encoding'] if 'encoding' in dbconf else defaults.DB_ENCODING
enginetype = dbconf['enginetype']
destination = dbconf['destination']
if enginetype == 'sqlite':
dbstring = '%s:///%s' % (enginetype, destination)
else:
username = dbconf['username']
password = dbconf['password']
db = dbconf['db']
port = dbconf['port']
dbstring = '%s://%s:%s@%s:%s/%s' % (enginetype, username, password, destination, port, db)
return create_engine(dbstring, encoding=encoding)
def get(self):
answer = []
logging.debug(' * Searching!')
mode = self.get_query_argument('mode', settings.get('mode'))
if not mode in settings.get_modes():
message = "Unknown mode: {}. Available: {}".format(
mode, ', '.join(settings.get_modes()))
error = errors.ConfigurationError(message, code=400)
self.return_error(error)
return
toformat = self.get_query_argument('format', False)
inp_subtypes = self.get_query_argument('subtypes', [])
if inp_subtypes:
inp_subtypes = inp_subtypes.split(',')
logging.debug('inp_subtypes %s', inp_subtypes)
word = self.get_query_argument('q', '')
contains = self.get_query_argument('contains',
'') in [True, 'true', 'True']
logging.debug('word %s', word)
lang = self.get_query_argument('lang', 'sv')
if lang not in settings.get('languages', mode):
message = "Unknown language: {}. Available: {}".format(
lang, ', '.join(settings.get('languages', mode)))
error = errors.QueryError(message)
self.return_error(error)
return
if toformat in ['html', 'pdf']:
size = int(settings.get('maxsize_export', mode))
else:
size = int(
self.get_query_argument('size', settings.get('maxsize', mode)))
subtypes = filter_public_subtypes(inp_subtypes, mode)
logging.debug(' * Subtypes %s', subtypes)
if not subtypes:
logging.warning(' * No public subtypes!')
message = "Subtype(s) {} not public".format(
', '.join(inp_subtypes))
error = errors.QueryError(message)
self.return_error(error)
return
url = settings.karp + '/query?%s'
params = {
'resource': settings.get('resource', mode),
'mode': settings.get('mode', mode),
'size': size
}
overflow = False
if not word and toformat not in ['html', 'pdf']:
word = limit_query(subtypes, lang, mode)
if word:
overflow = True
params['q'] = build_query(word, subtypes, contains, lang, mode)
if lang != settings.get('sourcelanguage', mode):
params['sort'] = settings.get('targetsort', mode)
data = make_call(url, params, mode)
if toformat == 'html':
if settings.get('myurl', mode):
cssurl = settings.get('myurl', mode)
else:
cssurl = "{}://{}".format(self.request.protocol,
self.request.host)
cssurl += "/css?mode=" + mode
html = convert.format_posts(data,
settings.get('mode', mode),
toformat='html',
css=cssurl)
self.write(html)
return
total = data.get('hits', {}).get('total', 0)
hits = data.get('hits', {}).get('hits', [])
for ans in hits:
source = ans.get('_source', {})
answer.append(source)
logging.debug('overflow? %s > %s', total, size)
self.write({'result': answer, 'overflow': overflow or total > size})
"EXAMPLE": True,
"MYSQL_HOST": "localhost",
"NAME": "BRUNO",
"PORT": 8001,
"PRESIDENT": "Lula",
"PROJECT": "hello_world",
"SALARY": 2000,
"VERSION": 1,
"WORKS": "validator",
"MYSQL_PASSWD": "SuperSecret",
"FOOBAR": "EMPTY",
}
for key, value in assertions.items():
found = settings.get(key)
assert found == getattr(settings, key)
assert found == value, f"expected: {key}: [{value}] found: [{found}]"
assertions = {
"AGE": 15,
"A_DICT": {"NESTED_1": {"NESTED_2": {"NESTED_3": {"NESTED_4": 1}}}},
"BASE_IMAGE": "bla",
"DEV_SERVERS": ["127.0.0.1", "localhost", "development.com"],
"EXAMPLE": True,
"MYSQL_HOST": "development.com",
"NAME": "MIKE",
"PORT": 8001,
"PRESIDENT": "Lula",
"PROJECT": "hello_world",
"4c239561b64f2353819452073f2ec7f62a5ad66f533868f89f7af862584cdee9",
"asset_type": "credit_alphanum4",
"asset_code": "HOT",
"asset_issuer":
"GDSB3JZDYKLYKWZ6NXDPPGPCYJ32ISMTZ2LVF5PYQGY4B4FGNIU2M5BJ",
"from":
"GDHH7XOUKIWA2NTMGBRD3P245P7SV2DAANU2RIONBAH6DGDLR5WISZZI",
"to":
"GAULEK4CU7IYZTFVKA4EG3RQLKB7LCSYX2WI46C2KXLDUJGQTSH2JWTD",
"amount": "20.0000000",
},
]
result = await get_transaction(
"4c239561b64f2353819452073f2ec7f62a5ad66f533868f89f7af862584cdee9")
host = settings.get('HOST', None)
expect_data = {
'transaction_id':
'4c239561b64f2353819452073f2ec7f62a5ad66f533868f89f7af862584cdee9',
'@id':
f"{host}{reverse('transaction', transaction_hash='4c239561b64f2353819452073f2ec7f62a5ad66f533868f89f7af862584cdee9')}",
'paging_token':
'34980756279271424',
'ledger':
8_144_592,
'created_at':
'2018-03-28T08:34:22Z',
'source_account':
'GDBNKZDZMEKXOH3HLWLKFMM7ARN2XVPHWZ7DWBBEV3UXTIGXBTRGJLHF',
'source_account_sequence':
'33497802856202246',
async def test_get_escrow_wallet_success_trusted_hot(mock_address):
balances = [
{
'balance': '7.0000000',
'limit': '922337203685.4775807',
'asset_type': 'credit_alphanum4',
'asset_code': settings['ASSET_CODE'],
'asset_issuer': settings['ISSUER'],
},
{
'balance': '10.0000000',
'limit': '1000',
'asset_type': 'credit_alphanum4',
'asset_code': 'PTKN',
'asset_issuer': settings['ISSUER'],
},
{
'balance': '9.9999200',
'asset_type': 'native'
},
]
mock_address.return_value = StellarWallet(balances)
instance = mock_address.return_value
instance.signers = [
{
'public_key': 'provider_address',
'weight': 1
},
{
'public_key': 'creator_address',
'weight': 1
},
{
'public_key': 'destination_address',
'weight': 0
},
]
actual_data = await get_escrow_wallet_detail(
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')
host = settings.get('HOST', None)
expect_data = {
'@id':
reverse('escrow-address',
escrow_address=
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD'),
'escrow_address':
'GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD',
'asset': {
settings['ASSET_CODE']: '7.0000000',
'XLM': '9.9999200'
},
'sequence':
'1',
'generate-wallet':
f"{host}{reverse('escrow-generate-wallet', escrow_address='GBVJJJH6VS5NNM5B4FZ3JQHWN6ANEAOSCEU4STPXPB24BHD5JO5VTGAD')}",
'data': {
'name': 'UnitTest',
'age': '30'
},
'signers': [{
'public_key': 'provider_address',
'weight': 1
}, {
'public_key': 'creator_address',
'weight': 1
}],
}
assert actual_data == expect_data
dataline = [float(data[0])/100 for data in item['data']]
self.write(
json(
{
'status' : 200,
'timeline' : timeline,
'series' :
[{'name': item['domain'], 'data': dataline}]
}
)
)
except BaseException, err:
print err
traceback.print_exc()
self.write(json({'status' : 400}))
app = tornado.web.Application([
(r"/smartbuyer/price", PriceTrendHandler),
(r"/", MainHandler),
])
dbclient = MongoClient.from_settings(settings.get('MONGODB'))
dbclient.open()
domain_table_mapping = settings.get('DOMAIN_TABLE_MAPPING')
if __name__ == "__main__":
app.listen(10001)
loop = tornado.ioloop.IOLoop.instance()
tornado.autoreload.start(loop)
loop.start()
def get(self, *args):
mode = self.get_query_argument('mode', settings.get('mode'))
full_url = settings.get('css', mode)
req = urllib.request.Request(full_url)
self.set_header('Content-Type', 'text/css')
self.write(urllib.request.urlopen(req).read())
dataline = [float(data[0]) / 100 for data in item['data']]
self.write(
json({
'status': 200,
'timeline': timeline,
'series': [{
'name': item['domain'],
'data': dataline
}]
}))
except BaseException, err:
print err
traceback.print_exc()
self.write(json({'status': 400}))
app = tornado.web.Application([
(r"/smartbuyer/price", PriceTrendHandler),
(r"/", MainHandler),
])
dbclient = MongoClient.from_settings(settings.get('MONGODB'))
dbclient.open()
domain_table_mapping = settings.get('DOMAIN_TABLE_MAPPING')
if __name__ == "__main__":
app.listen(10001)
loop = tornado.ioloop.IOLoop.instance()
tornado.autoreload.start(loop)
loop.start()
def update_subtypes(subtypes, mode):
""" Update the subtypes file """
open(settings.get('subtypes', mode), encoding='utf-8',
mode='w').write('\n'.join(subtypes))
def get_subtypes(mode):
""" Read all subtypes for this mode from file """
return [
s.strip() for s in open(settings.get('subtypes', mode),
encoding='utf-8').readlines() if s
]
