def configure(cls, settings):
kwargs = super(DynamoCache, cls).configure(settings)
access_key = settings.get('db.aws_access_key_id')
secret_key = settings.get('db.aws_secret_access_key')
region = settings.get('db.region_name')
host = settings.get('db.host')
port = int(settings.get('db.port', 8000))
secure = asbool(settings.get('db.secure', False))
namespace = settings.get('db.namespace', ())
graceful_reload = asbool(settings.get('db.graceful_reload', False))
if host is not None:
connection = DynamoDBConnection.connect(region,
host=host,
port=port,
is_secure=secure,
access_key=access_key,
secret_key=secret_key)
elif region is not None:
connection = DynamoDBConnection.connect(region,
access_key=access_key,
secret_key=secret_key)
else:
raise ValueError("Must specify either db.region_name or db.host!")
kwargs['engine'] = engine = Engine(namespace=namespace,
dynamo=connection)
kwargs['graceful_reload'] = graceful_reload
engine.register(DynamoPackage, PackageSummary)
LOG.info("Checking if DynamoDB tables exist")
engine.create_schema()
return kwargs
def generate_cf_dynamo_schema(target):
dynamo_connection = DynamoDBConnection()
class FakeClient(object):
def create_table(self, *args, **kwargs):
write_schema_to_yaml(target, **kwargs)
return {}
client = FakeClient()
dynamo_connection.client = client
class FakeDynamo(object):
def list_tables(self):
return []
def create_table(self, *args):
result = dynamo_connection.create_table(*args)
def describe_table(self, *args):
StatusStruct = namedtuple('Status', 'status')
return StatusStruct(status='ACTIVE')
dynamo = FakeDynamo()
engine = Engine()
engine.dynamo = dynamo
sys.path = ['{}/app/models'.format(target)] + sys.path
modelModules = glob.glob('{}/app/models'.format(target) + '/*.py')
models = [basename(f)[:-3] for f in modelModules if isfile(f)]
for modelName in models:
if modelName != '__init__':
engine.register(getattr(importlib.__import__(modelName),
modelName))
engine.create_schema()
def configure(cls, settings):
kwargs = super(DynamoCache, cls).configure(settings)
access_key = settings.get('db.access_key')
secret_key = settings.get('db.secret_key')
region = settings.get('db.region')
host = settings.get('db.host')
port = int(settings.get('db.port', 8000))
secure = asbool(settings.get('db.secure', False))
namespace = settings.get('db.namespace', ())
if region is not None:
connection = DynamoDBConnection.connect(region,
access_key=access_key,
secret_key=secret_key)
elif host is not None:
connection = DynamoDBConnection.connect('us-east-1',
host=host,
port=port,
is_secure=secure,
access_key=access_key,
secret_key=secret_key)
else:
raise ValueError("Must specify either db.region or db.host!")
kwargs['engine'] = engine = Engine(namespace=namespace,
dynamo=connection)
engine.register(DynamoPackage, PackageSummary)
engine.create_schema()
return kwargs
def rundb(target):
"""
Start running a local DynamoDB instance.
:param target:
:return:
"""
load_env(target)
os.environ['AWS_REGION'] = 'us-west-2'
shared_db = './dynamo_db/shared-local-instance.db'
if os.path.exists(shared_db):
os.remove(shared_db)
dynamo_command = [
'java',
'-Djava.library.path={}/dynamo_db/DynamoDBLocal_lib'.format(CWD),
'-jar', '{}/dynamo_db/DynamoDBLocal.jar'.format(CWD), '-sharedDb',
'-dbPath', './dynamo_db'
]
try:
dynamo_process = subprocess.Popen(dynamo_command,
stdin=subprocess.PIPE,
stderr=subprocess.STDOUT)
except Exception as e:
pass
try:
'''
Connect to DynamoDB and register and create tables for application models.
'''
engine = Engine()
engine.connect(os.environ['AWS_REGION'],
host='localhost',
port=8000,
access_key='anything',
secret_key='anything',
is_secure=False)
# load models
sys.path = ['./app/models'] + sys.path
modelModules = glob.glob('./app/models' + "/*.py")
models = [basename(f)[:-3] for f in modelModules if isfile(f)]
for modelName in models:
if modelName != '__init__':
engine.register(getattr(__import__(modelName), modelName))
engine.create_schema()
tables = [table for table in engine.dynamo.list_tables()]
print("This engine has the following tables " + str(tables))
for table in tables:
engine.dynamo.describe_table(table)
except Exception as e:
# IF anything goes wrong, then we self-destruct.
dynamo_process.kill()
raise e
# Wait for process to finish.
dynamo_process.wait()
def configure_flywheel_engine(graph):
"""
Create the flywheel engine.
"""
namespace = graph.config.dynamodb.namespace
if graph.metadata.testing:
from microcosm_dynamodb.mockengine import MockEngine
engine = MockEngine(namespace="test-")
else:
engine = Engine(namespace=namespace)
engine.connect_to_region(graph.config.dynamodb.region)
return engine
def __init__(self, args):
self.engine = Engine()
self.engine.connect_to_region('eu-west-1')
# Register our model with the engine so it can create the Dynamo table
self.engine.register(Approval)
# Create the dynamo table for our registered model
self.engine.create_schema()
self.args = args
# Setup logging
if args.verbose:
loglevel = logging.DEBUG
else:
loglevel = logging.INFO
logging.basicConfig(format="%(levelname)s: %(message)s",
level=loglevel)
def __init__(self, request):
self.engine = Engine()
self.engine.connect_to_host(host='localhost',
port=8000,
is_secure=False)
self._repos = {
"user": UserRepository(self.engine),
"user_credential": UserCredentialRepository(self.engine),
"access_token": AccessTokenRepository(self.engine),
"refresh_token": RefreshTokenRepository(self.engine),
"client_session": ClientSessionRepository(self.engine),
"village": VillageRepository(self.engine),
"resident": ResidentRepository(self.engine),
"event": EventRepository(self.engine),
"behavior": BehaviorRepository(self.engine),
}
self._message_handler = MessageHandler(self)
def configure(cls, settings):
kwargs = super(DynamoCache, cls).configure(settings)
access_key = settings.get("db.aws_access_key_id")
secret_key = settings.get("db.aws_secret_access_key")
region = settings.get("db.region_name")
host = settings.get("db.host")
port = int(settings.get("db.port", 8000))
secure = asbool(settings.get("db.secure", False))
namespace = settings.get("db.namespace", ())
graceful_reload = asbool(settings.get("db.graceful_reload", False))
tablenames = aslist(settings.get("db.tablenames", []))
if tablenames:
if len(tablenames) != 2:
raise ValueError("db.tablenames must be a 2-element list")
DynamoPackage.meta_.name = tablenames[0]
PackageSummary.meta_.name = tablenames[1]
if host is not None:
connection = DynamoDBConnection.connect(
region,
host=host,
port=port,
is_secure=secure,
access_key=access_key,
secret_key=secret_key,
)
elif region is not None:
connection = DynamoDBConnection.connect(region,
access_key=access_key,
secret_key=secret_key)
else:
raise ValueError("Must specify either db.region_name or db.host!")
kwargs["engine"] = engine = Engine(namespace=namespace,
dynamo=connection)
kwargs["graceful_reload"] = graceful_reload
engine.register(DynamoPackage, PackageSummary)
LOG.info("Checking if DynamoDB tables exist")
engine.create_schema()
return kwargs
def write_data(namepsace: str, val3_base: str, port: int) -> None:
db = Engine(namespace=namepsace)
db.connect(
'local',
access_key='AK',
secret_key='SK',
host='localhost',
port=port,
is_secure=False,
)
db.register(Data)
db.create_schema()
started = datetime.utcnow()
db.save(items=[
Data(id=str(i), val1=str(i), val2=i, val3=f'{val3_base}-{i}') for i in range(100)
])
elapsed = datetime.utcnow() - started
print(f'{namepsace} elapsed time: {elapsed}')
def setup_dynamodb(models,
region=DB_REGION,
access_key=DB_KEY,
secret_key=DB_SECRET,
host=DB_HOST,
port=DB_PORT,
is_secure=DB_SECURE):
"""
Setups DynamoDB Local and registers flywheel models.
Parameters:
models : list
List of flywheel models to register
region : str, optional
access_key : str, optional
secret_key : str, optional
host : str, optional
port : int, optional
is_secure : bool, optional
"""
# Create an engine and connect to DynamoDB Local
engine = Engine()
engine.connect(region,
access_key=access_key,
secret_key=secret_key,
host=host,
port=port,
is_secure=is_secure)
# Register models with the engine so it can create Dynamo tables
engine.register(*models)
# Drop any existing schema in the database, so we can sync it up with
# current schema. This is only for development.
engine.delete_schema()
# Create the dynamo table for our registered models
engine.create_schema()
return engine
def connect(*args, **kwargs):
engine = getattr(current_module, 'engine')
session = getattr(current_module, 'session') or kwargs.pop('session', None)
if engine:
return engine
else:
engine = Engine()
# Connect the engine to either a local DynamoDB or a particular region.
if ('USE_LOCAL_DB' in os.environ
and os.environ['USE_LOCAL_DB'] == 'True'):
engine.connect(os.environ['AWS_REGION'],
host='localhost',
port=8000,
access_key='anything',
secret_key='anything',
is_secure=False,
session=session)
elif ('CI' in os.environ and os.environ['CI'] == 'True'):
engine.connect_to_region(os.environ['AWS_REGION'], session=session)
else:
engine.connect_to_region(os.environ['AWS_REGION'])
setattr(current_module, 'engine', engine)
return engine
def __init__(self, command_name, json_data, command_argument):
self.command_name = command_name
self.command_argument = command_argument
# Namespace the approval lock
self.data = json.loads(json_data)
self.wait_lock = 10
self.pool = ''
self.engine = Engine()
# allow debug logging to console for tests
if os.getenv('RESOURCE_DEBUG', False) or self.data.get('source', {}).get('debug', False):
log.basicConfig(level=log.DEBUG)
else:
logfile = tempfile.NamedTemporaryFile(delete=False, prefix='log')
log.basicConfig(level=log.DEBUG, filename=logfile.name)
stderr = log.StreamHandler()
stderr.setLevel(log.INFO)
log.getLogger().addHandler(stderr)
log.debug('command: %s', command_name)
log.debug('input: %s', self.data)
log.debug('args: %s', command_argument)
log.debug('environment: %s', os.environ)
# logging.basicConfig(level=logging.DEBUG)
# parsing arguments
PARSER = argparse.ArgumentParser(description='Client message processor')
PARSER.add_argument('API_token', help="the individual API token given to your team")
PARSER.add_argument('API_base', help="the base URL for the game API")
ARGS = PARSER.parse_args()
# defining global vars
API_BASE = ARGS.API_base
# 'https://csm45mnow5.execute-api.us-west-2.amazonaws.com/dev'
APP = Flask(__name__)
DDB_ENGINE = Engine()
DDB_ENGINE.connect_to_region('eu-central-1')
Message.meta_.name = 'gameday-production'
DDB_ENGINE.register(Message)
#ELASTICACHE_CLIENT = boto3.client('elasticache')
# creating flask route for type argument
@APP.route('/ping', methods=['GET', 'POST'])
def healthcheck():
return "ok"
@APP.route('/', methods=['GET', 'POST'])
def main_handler():
class Dynamo():
engine = Engine()
def init_engine(self, dy_region, use_local, local_port=8000, create_tables=False, register_models=True, client_id="CLIENT_ID", client_secret="secret", client_metadata=None):
# Create an engine and connect to an AWS region
if use_local:
self.engine.connect(host='localhost', port=local_port, region='', is_secure=False)
else:
self.engine.connect(region=dy_region, is_secure=False)
# Register models with the engine so it can create the Dynamo table
if register_models:
self.engine.register(OAuth2DynamoToken)
self.engine.register(OAuth2DynamoClient)
self.engine.register(DynamoPasswordResetToken)
# Create the dynamo tables
if create_tables:
self.engine.delete_schema()
self.engine.create_schema()
self.create_client(client_id, client_secret, client_metadata)
# token functions
def save_token(self, token):
self.engine.save(token)
def get_token(self, _access_token):
token = self.engine.get(OAuth2DynamoToken, access_token=_access_token)
if not token:
raise InvalidTokenError()
else:
return token
def get_token_by_refresh(self, _refresh_token):
token = self.engine.query(OAuth2DynamoToken).filter(OAuth2DynamoToken.refresh_token == _refresh_token).index('refresh-index').one()
if not token:
raise InvalidTokenError()
else:
# refresh gets fields not projected by index
token.refresh()
return token
def get_tokens_by_userid(self, _user_id):
tokens = self.engine.query(OAuth2DynamoToken).filter(OAuth2DynamoToken.user_id == _user_id).index('user-index')
if not tokens:
raise InvalidTokenError()
else:
# refresh gets fields not projected by index
for token in tokens:
token.refresh()
return tokens
def delete_tokens_by_userid(self, _user_id):
self.engine.query(OAuth2DynamoToken).filter(OAuth2DynamoToken.user_id == _user_id).index('user-index').delete()
def delete_token(self, _access_token):
self.engine.delete_key(OAuth2DynamoToken, access_token=_access_token)
# client functions
def get_client(self, _client_id):
return self.engine.get(OAuth2DynamoClient, client_id=_client_id)
def save_client(self, client):
self.engine.save(client)
def create_client(self, client_id="CLIENT_ID", client_secret="secret", client_metadata=None):
client_id_issued_at = int(time.time())
client = OAuth2DynamoClient(
client_id=client_id,
client_id_issued_at=client_id_issued_at
)
if not client_metadata:
client_metadata = {
"client_name": "Client Name",
"grant_types": ["password", "refresh_token"],
"scope": "profile",
"token_endpoint_auth_method": "client_secret_basic"
}
client.set_client_metadata(client_metadata)
client.client_secret = client_secret
self.save_client(client)
# password token functions
def save_pw_token(self, token):
self.engine.save(token)
def get_pw_token(self, user_id, reset_code):
token = self.engine.get(DynamoPasswordResetToken, user_id=user_id, reset_code=reset_code)
if not token:
raise InvalidTokenError()
else:
return token
def delete_pw_token(self, user_id, reset_code):
self.engine.delete_key(DynamoPasswordResetToken, user_id=user_id, reset_code=reset_code)
from flywheel import Engine
from pyramid.paster import bootstrap
from werewolf.app.resource import RootResource
from werewolf.domain.base import Identity
from werewolf.domain.user import *
from werewolf.domain.user.repository import *
from werewolf.domain.game import *
from werewolf.domain.game.repository import *
from werewolf.domain.game.exception import GameException, GameNotFinished
env = bootstrap('development.ini')
context = RootResource(None)
engine = Engine()
engine.connect_to_host(host='localhost', port=8000, is_secure=False)
# repo_user = UserRepository(engine)
# a = repo_user.get_by_name('COM1')
game = GameService(context, '4db80ce9c0b445728a39d1d47f2cb742')
try:
game.start()
except GameException as e:
print e.message
targets = game.execute_night()
pprint(targets)
from dynamo3 import DynamoDBConnection
from flywheel import Engine
from auth.auth_main import *
connection = DynamoDBConnection.connect(region=DynamoAuth.region,
access_key=DynamoAuth.access_key,
secret_key=DynamoAuth.secret_key,
host="localhost",
port=8000,
is_secure=False)
engine = Engine(connection)
def main(pargs):
global redis
if pargs.production:
serverConf = configobj.ConfigObj('production.ini')
else:
serverConf = configobj.ConfigObj('develop.ini')
routes = [
(r"/auth/login", FacebookGraphLoginHandler),
(r"/", HomeHandler),
(r"/referral/([^/]+)", ReferralHandler),
(r"/r/([^/]+)", ReferralHandler),
(r'/(favicon.ico)', StaticFileHandler, {
"path": "./static/"
}),
]
for api in [game, tips, user, referral, prizes]:
routes.extend(get_routes(api))
if pargs.admin:
routes.extend(get_routes(admin))
routes.extend(get_routes(box))
from encontact import UserDataHandler
routes.extend([
(r"/admin/encontact?/", UserDataHandler),
])
pprint(routes, indent=4)
mailer = Mail(aws_access_key_id=serverConf['ses']['acceskeyid'],
aws_secret_access_key=serverConf['ses']['secretacceskeyid'],
region=serverConf['ses']['region'],
sender=serverConf['ses']['sender'],
template=serverConf['ses']['templates'])
if pargs.production:
dyn = DynamoDBConnection.connect(
region=serverConf['dynamo']['region'],
access_key=serverConf['dynamo']['acceskeyid'],
secret_key=serverConf['dynamo']['secretacceskeyid'])
session_settings = dict(
driver="redis",
force_persistence=True,
cache_driver=True,
driver_settings=dict(
host=serverConf['redis']['host'],
port=int(serverConf['redis']['port']),
db=int(serverConf['redis']['db']),
max_connections=1024,
),
)
pool = ConnectionPool(max_connections=2,
host=serverConf['redis']['host'],
port=int(serverConf['redis']['port']),
db=int(serverConf['redis']['db']) + 1)
pool2 = ConnectionPool(max_connections=2,
host=serverConf['redis']['host'],
port=int(serverConf['redis']['port']),
db=int(serverConf['redis']['db']))
else:
dyn = DynamoDBConnection.connect(region='sp-east',
host='127.0.0.1',
port=8000,
is_secure=False,
access_key='asdas',
secret_key='123ads')
session_settings = dict(
driver="redis",
force_persistence=True,
cache_driver=True,
driver_settings=dict(
host='localhost',
port=6379,
db=0,
max_connections=1024,
),
)
pool = ConnectionPool(max_connections=2,
host='localhost',
port=6379,
db=1)
pool2 = ConnectionPool(max_connections=2,
host='localhost',
port=6379,
db=0)
redis = Redis(connection_pool=pool)
redis2 = Redis(connection_pool=pool2)
engine = Engine(dynamo=dyn)
log = logging.getLogger(__name__)
a = logging.basicConfig(
level=logging.INFO,
format=
'[ %(asctime)s ][ %(levelname)s ][ %(filename)20s:%(lineno)4s - %(funcName)20s() ] %(message)s',
datefmt='%m-%d %H:%M',
filename='log/nextgame.log',
filemode='a')
log.addHandler(a)
settings = {
"debug": False,
'xsrf_cookies': False,
'serverConfig': serverConf,
'instance': serverConf.get('instance'),
'engine': engine,
'facebook_api_key': serverConf['facebook']['key'],
'facebook_secret': serverConf['facebook']['secret'],
'session': session_settings,
'template_path': serverConf['ses']['templates'],
"login_url": "/auth/login/",
"cookie_secret": 'sopadeletrinhas123',
"mailer": mailer,
"production": False
}
if (pargs.debug):
# log.setLevel(logging.DEBUG)
log.debug('DEBUGGING LOG')
settings['debug'] = True
app = Application(routes=routes,
settings=settings,
db_conn={
'ping': redis,
'session': redis2
})
if pargs.provision:
game.models.create_schemas(engine)
tips.models.create_schemas(engine)
referral.models.create_schemas(engine)
if (pargs.production):
print('Server Production Starting')
server = tornado.httpserver.HTTPServer(app)
server.bind(serverConf['tornado']['port'])
server.start(int(serverConf['tornado']['instances']))
tornado.ioloop.IOLoop.configure(TornadoUvloop)
else:
print('Server Develop Starting')
app.listen(serverConf['tornado']['port'])
tornado.ioloop.IOLoop.configure(TornadoUvloop)
tornado.ioloop.IOLoop.current().start()
updated_at = Field(data_type=datetime.datetime, nullable=True)
deleted_at = Field(data_type=datetime.datetime,
nullable=True,
index='create-index')
referral = Field(data_type=str, default='')
avatar = Field(data_type=dict, nullable=True)
win = Field(data_type=dict, nullable=True)
win_email = Field(data_type=list, nullable=True)
is_dirty = Field(data_type=bool, default=False)
is_admin = Field(data_type=int, default=0, index='admin-index')
dyn = DynamoDBConnection.connect(region=FLYWHEEL_REGION,
access_key=AWS_ACCESS_KEY,
secret_key=AWS_SECRET_ACCESS_KEY)
db = Engine(dynamo=dyn)
cont = {
'easy': [],
'medium': [],
'hard': [],
'impossible': [],
}
if __name__ == '__main__':
context = db.scan(User).filter(User.mobile != None).gen()
print("DONE SCAN")
for u in context:
try:
if u.cpf is not None:
for i in u.win.values():
import json
import os
from flask import Flask
from flywheel import Engine
from flywheel.query import EntityNotFoundException
from service.models import Data
db = Engine(namespace=os.environ['DB_NAMESPACE'])
db.connect(
'local',
access_key='AK',
secret_key='SK',
host='local-db',
port=
8000, # The application communicates on the docker-compose network with local DynamoDB
is_secure=False,
)
app = Flask(__name__)
@app.route('/health', methods=['GET'])
def health():
return json.dumps({'status': 'success'})
@app.route('/test/<id_>', methods=['GET'])
def test(id_: int):
return json.dumps({