def __init__(self, hadoop_dir, cluster=None):
self.hadoop_dir = hadoop_dir
# need mapred-site.xml
self.config = ConfigFactory.get_config( \
"%s/conf/mapred-site.xml" % hadoop_dir)
self.cluster = cluster
self.running = False
self._jtpid = None
self._ttpid = None
def __init__(self, hadoop_dir, cluster=None):
self.hadoop_dir = hadoop_dir
# need mapred-site.xml
self.config = ConfigFactory.get_config( \
"%s/conf/mapred-site.xml" % hadoop_dir)
self.cluster = cluster
self.running = False
self._jtpid = None
self._ttpid = None
def run(cls, eth_passphrase, eth_auth_token, sol_file):
"""
Runs the backend
"""
# Note: except for stream_logger, every other import
# to a subpackage of qsp_prototol_node must be
# performed at this point
from audit import QSPAuditNode
from config import ConfigFactory
from utils.stop import Stop
cfg = ConfigFactory.create_from_dictionary(
Program.__yaml_config,
Program.__env,
account_passwd=eth_passphrase,
auth_token=eth_auth_token,
)
logger.info("Initializing QSP Audit Node")
logger.debug("account: {0}".format(cfg.account))
logger.debug("analyzers: {0}".format(cfg.analyzers))
logger.debug("audit contract address: {0}".format(
cfg.audit_contract_address))
logger.debug("min_price_in_qsp: {0}".format(cfg.min_price_in_qsp))
logger.debug("evt_polling: {0}".format(cfg.evt_polling))
logger.debug("audit contract address: {0}".format(
cfg.audit_contract_address))
# Based on the provided configuration, instantiates a new
# QSP audit node
audit_node = QSPAuditNode(cfg)
Stop.register(audit_node)
if QSPAuditNode.is_police_officer(cfg):
logger.info("Running QSP node (performs audits and police checks)")
else:
logger.info("Running QSP node (performs audits only)")
# If a sol file is given, produce the audit report for that file and exit
if sol_file:
_, audit_report = audit_node.get_full_report(requestor=cfg.account,
uri=sol_file,
request_id=1)
pprint(audit_report)
# Runs the QSP audit node in a busy loop fashion
else:
try:
audit_node.start()
except Exception as error:
if audit_node is not None:
audit_node.stop()
raise error
def test_create_analyzers(self):
analyzers_config = "config list"
logger = "logger"
return_value = "value"
config = ConfigFactory.create_empty_config()
config._Config__analyzers_config = analyzers_config
config._Config__logger = logger
utils = ConfigUtilsMock()
utils.expect('create_analyzers',
{'analyzers_config': analyzers_config, 'logger': logger},
return_value)
result = config._Config__create_analyzers(utils)
self.assertEqual(return_value, result)
utils.verify()
def test_create_eth_provider(self):
name = "provider name"
args = "arguments"
return_value = "value"
config = ConfigFactory.create_empty_config()
config._Config__eth_provider_name = name
config._Config__eth_provider_args = args
utils = ConfigUtilsMock()
utils.expect('create_eth_provider',
{'provider': name, 'args': args},
return_value)
result = config._Config__create_eth_provider(utils)
self.assertEqual(return_value, result)
utils.verify()
def test_load_config(self):
config_file_uri = resource_uri("test_config.yaml")
config = ConfigFactory.create_from_file(config_file_uri, "dev", validate_contract_settings=False)
self.assertIsNotNone(config.eth_provider)
self.assertIsNotNone(config.web3_client)
self.assertIsNotNone(config.account)
self.assertIsNotNone(config.analyzers)
self.assertIsNotNone(config.upload_provider)
self.assertIsNotNone(config.metric_collection_destination_endpoint)
self.assertEqual(5, config.min_price_in_qsp)
self.assertEqual(0, config.gas_price_wei)
self.assertEqual(5, config.evt_polling)
self.assertEqual(2, len(config.analyzers))
self.assertEqual(5, config.start_n_blocks_in_the_past)
self.assertEqual(1, config.block_discard_on_restart)
self.assertFalse(config.enable_police_audit_polling)
def test_create_web3_client(self):
eth_provider = "eth_provider"
account_passwd = "account password"
account_keystore_file = "./mykey.json"
created_web3_provider = "created provider"
config = ConfigFactory.create_empty_config()
config._Config__eth_provider = eth_provider
config._Config__account_passwd = account_passwd
config._Config__account_keystore_file = account_keystore_file
utils = ConfigUtilsMock()
utils.expect('create_web3_client',
{'eth_provider': eth_provider, 'account_passwd': account_passwd,
'keystore_file': account_keystore_file, 'max_attempts': 30},
created_web3_provider)
result = config._Config__create_web3_client(utils)
self.assertEqual(created_web3_provider, result)
utils.verify()
def test_initialize(self):
config_file_uri = resource_uri("test_config.yaml")
config = ConfigFactory.create_from_file(
config_file_uri, "dev", validate_contract_settings=False)
log_streaming.initialize("account",
config_value(config, "/logging/streaming",
{}),
force=True)
self.assertEqual(get_config(), {})
self.assertEqual(get_account(), "account")
self.assertEqual(get_loggers(), {})
try:
log_streaming.initialize("account", {})
self.fail("An exception was expected")
except Exception:
# expected
pass
def create_app():
app = Flask(__name__)
app.config.from_object(ConfigFactory.factory().__class__)
# # init extensions
db.init_app(app)
migrate.init_app(app, db)
ma.init_app(app)
# # add custom commands
app.cli.add_command(sync_teams)
app.cli.add_command(sync_players)
app.cli.add_command(sync_seasons)
app.cli.add_command(sync_games)
app.cli.add_command(sync_new_games)
with app.app_context():
# import database models
from app.database.models.season import SeasonModel
from app.database.models.team import TeamModel
from app.database.models.player import PlayerModel
from app.database.models.game import GameModel
from app.database.models.player_team_season import PlayerSeasonTeamModel
from app.database.models.teams_stats import TeamsStatsModel
from app.database.models.players_stats import PlayersStatsModel
# # import blueprints
# views
from app.views.home import home_bp
from app.views.season import season_bp
from app.views.team import team_bp
from app.views.player import player_bp
from app.views.game import game_bp
# register blueprints
# views
app.register_blueprint(home_bp, url_prefix="/home")
app.register_blueprint(season_bp, url_prefix="/api/season")
app.register_blueprint(team_bp, url_prefix="/api/team")
app.register_blueprint(player_bp, url_prefix="/api/player")
app.register_blueprint(game_bp, url_prefix="/api/game")
# # end import blueprints
return app
def test_inject_token_auth(self):
auth_token = "abc123456"
endpoint = "https://test.com/?token={0}".format(auth_token)
target_env = "dev"
# Sets the dictionary to be returned by a call to load_config
config_file = fetch_file(resource_uri("test_config_with_auth_token.yaml"))
config_yaml = load_yaml(config_file)
dummy_utils = ConfigUtilsDummy({'load_config': config_yaml[target_env]})
config = ConfigFactory.create_from_file(
environment=target_env,
config_file_uri="some dummy uri",
auth_token=auth_token,
validate_contract_settings=False,
config_utils=dummy_utils,
)
self.assertEqual(config.auth_token, auth_token)
self.assertEqual(config.eth_provider_args['endpoint_uri'], endpoint)
def test_create_upload_provider(self):
account = "account"
upload_provider_name = "provider name"
upload_provider_args = "arguments"
upload_provider = "value"
config = ConfigFactory.create_empty_config()
config._Config__account = account
config._Config__upload_provider_name = upload_provider_name
config._Config__upload_provider_is_enabled = True
config._Config__upload_provider_args = upload_provider_args
utils = ConfigUtilsMock()
utils.expect('create_upload_provider',
{'account': account,
'upload_provider_name': upload_provider_name,
'upload_provider_args': upload_provider_args,
'upload_provider_is_enabled': True},
upload_provider)
result = config._Config__create_upload_provider(utils)
self.assertEqual(upload_provider, result)
utils.verify()
def fetch_config(inject_contract=False):
# create config from file, the contract is not provided and will be injected separately
config_file_uri = resource_uri("test_config.yaml")
config = ConfigFactory.create_from_file(config_file_uri,
os.getenv("QSP_ENV",
default="dev"),
validate_contract_settings=False)
if inject_contract:
contract_source_uri = "./tests/resources/QuantstampAuditMock.sol"
contract_metadata_uri = "./tests/resources/QuantstampAudit-metadata.json"
audit_contract_metadata = load_json(fetch_file(contract_metadata_uri))
audit_contract_name = get(audit_contract_metadata, '/contractName')
addr, contract = __load_audit_contract_from_src(
config.web3_client, contract_source_uri, audit_contract_name,
config.account)
config._Config__audit_contract_address = addr
config._Config__audit_contract = contract
config_utils = ConfigUtils(config.node_version)
config_utils.check_configuration_settings(config)
return config
def test_create_components(self):
eth_provider_name = "eth provider name"
eth_provider_args = "eth provider arguments"
created_eth_provider = "created_eth_provider"
new_account = "0xc1220b0bA0760817A9E8166C114D3eb2741F5949"
account_passwd = "account password"
account_keystore_file = "./mykey.json"
new_private_key = "abcdefg"
account = "0x12345"
analyzers_config = "config list"
created_analyzers = "analyzers"
upload_provider_name = "upload provider name"
upload_provider_args = "upload provider arguments"
upload_provider = "created upload provier"
audit_contract_abi_uri = "some uri"
audit_contract_address = "0xc1220b0bA0760817A9E8166C114D3eb2741F5949"
created_audit_contract = "contract"
created_web3_client = Web3Mock()
config = ConfigFactory.create_empty_config()
config._Config__eth_provider_name = eth_provider_name
config._Config__eth_provider_args = eth_provider_args
config._Config__account = account
config._Config__account_passwd = account_passwd
config._Config__account_keystore_file = account_keystore_file
config._Config__analyzers_config = analyzers_config
config._Config__evt_db_path = "/tmp/evts.test"
config._Config__upload_provider_name = upload_provider_name
config._Config__upload_provider_args = upload_provider_args
config._Config__upload_provider_is_enabled = True
config._Config__audit_contract_abi_uri = audit_contract_abi_uri
config._Config__audit_contract_address = audit_contract_address
utils = ConfigUtilsMock()
utils.expect('create_eth_provider',
{'provider': eth_provider_name, 'args': eth_provider_args},
created_eth_provider)
utils.expect('create_web3_client',
{'eth_provider': created_eth_provider, 'account_passwd': account_passwd,
'keystore_file': account_keystore_file, 'max_attempts': 30},
(created_web3_client, new_account, new_private_key))
utils.expect('check_audit_contract_settings',
{'config': config},
None)
utils.expect('create_contract',
{'web3_client': created_web3_client, 'audit_contract_abi_uri': audit_contract_abi_uri,
'audit_contract_address': audit_contract_address},
created_audit_contract)
utils.expect('check_configuration_settings',
{'config': config},
None)
utils.expect('create_analyzers',
{'analyzers_config': analyzers_config},
created_analyzers)
utils.expect('create_upload_provider',
{'account': new_account,
'upload_provider_name': upload_provider_name,
'upload_provider_args': upload_provider_args,
'upload_provider_is_enabled': True},
upload_provider)
config._Config__create_components(utils)
self.assertEqual(created_eth_provider, config.eth_provider)
self.assertEqual(created_web3_client, config.web3_client)
self.assertEqual(new_account, config.account)
self.assertEqual(created_analyzers, config.analyzers)
self.assertEqual(upload_provider, config.upload_provider)
self.assertEqual(created_audit_contract, config.audit_contract)
utils.verify()
def read_config(config_file_name):
try:
config = ConfigFactory.from_yaml_file(config_file_name)
except ConfigException, e:
print e.message
sys.exit(2)
import logging
import traceback
from flask import Flask
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy
from flask.ext.socketio import SocketIO
from config import ConfigFactory
from common import errors
config = ConfigFactory.build_config()
app = Flask(__name__)
app.config.from_object(config)
api = Api(app, '/v1')
database = SQLAlchemy(app)
socketio = SocketIO(app)
def initialize():
_initialize_logging()
_initialize_resources()
_initialize_socketio()
socketio.run(app, host=config.HOST, port=config.PORT)
def _initialize_logging():
# TODO: add more specific configuration parameters
import logging
import traceback
from flask import Flask
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy
from flask.ext.socketio import SocketIO
from config import ConfigFactory
from common import errors
config = ConfigFactory.build_config()
app = Flask(__name__)
app.config.from_object(config)
api = Api(app, "/v1")
database = SQLAlchemy(app)
socketio = SocketIO(app)
def initialize():
_initialize_logging()
_initialize_resources()
_initialize_socketio()
socketio.run(app, host=config.HOST, port=config.PORT)
def _initialize_logging():
# TODO: add more specific configuration parameters
from flask import Flask
from config import ConfigFactory
from core.routes import register_routes
from core.docs import register_swagger_routes
from storage import register_storage
app = Flask(__name__)
# load configuration
configuration = ConfigFactory().get(app.config['ENV'])
app.config.from_object(configuration)
# define data source and create API endpoints
register_storage(app)
register_routes(app)
if app.config['ENV'] != 'testing':
register_swagger_routes(app)
if __name__ == '__main__':
app.run()
from apscheduler.schedulers.blocking import BlockingScheduler
import logging
import os
from bot import SynthweetixBot
from config import ConfigType, ConfigFactory
if __name__ == '__main__':
# Configuration
app_settings = os.getenv('CONFIGURATION', default='development')
type_ = ConfigType.reverse_lookup(app_settings)
cfactory = ConfigFactory()
config = cfactory.get(type_)
# Logging
logging.basicConfig(format='[%(asctime)s] [%(levelname)s] %(message)s',
level=config.LOG_LEVEL)
logging.info(f'Initializing Synthweetix in {app_settings} environment')
bot = SynthweetixBot(
config.TWITTER_CONSUMER_KEY, config.TWITTER_CONSUMER_SECRET,
config.TWITTER_ACCESS_TOKEN, config.TWITTER_ACCESS_SECRET,
config.ETHERSCAN_API_KEY, config.TRADE_VALUE_THRESHOLD,
config.EYE_CATCHER_THRESHOLD)
# Run once on startup
bot.execute()
# Run the bot periodically
if config.TRIGGER is not None: # In case the bot is deployed as a Heroku or Docker cron job.
scheduler = BlockingScheduler()
