def __init__(self, connData):
super(RDBReader, self).__init__()
rdb.set_loop_type('tornado')
#self.conn = rdb.connect(host=connData["host"], port=connData["port"], db=connData["db"], auth_key=connData["auth_key"])
self.conn = rdb.connect(host=connData["host"],
port=connData["port"],
db=connData["db"])
async def db_check():
"""Used to check if the required database/tables are setup"""
db_opts = config.db_opts
r.set_loop_type('asyncio')
# First try to connect, and see if the correct information was provided
try:
conn = await r.connect(**db_opts)
except r.errors.ReqlDriverError:
print("Cannot connect to the RethinkDB instance with the following information: {}".format(db_opts))
print("The RethinkDB instance you have setup may be down, otherwise please ensure you setup a"
" RethinkDB instance, and you have provided the correct database information in config.yml")
quit()
return
# Get the current databases and check if the one we need is there
dbs = await r.db_list().run(conn)
if db_opts['db'] not in dbs:
# If not, we want to create it
print('Couldn\'t find database {}...creating now'.format(db_opts['db']))
await r.db_create(db_opts['db']).run(conn)
# Then add all the tables
for table, key in required_tables.items():
print("Creating table {}...".format(table))
await r.table_create(table, primary_key=key).run(conn)
print("Done!")
else:
# Otherwise, if the database is setup, make sure all the required tables are there
tables = await r.table_list().run(conn)
for table, key in required_tables.items():
if table not in tables:
print("Creating table {}...".format(table))
await r.table_create(table, primary_key=key).run(conn)
print("Done checking tables!")
def __init__(self, ident, table):
super(RDBReader, self).__init__()
ioloop.IOLoop.current().add_callback(self.print_changes)
rdb.set_loop_type('tornado')
self.ident = ident
self.table = table
def server():
"""
Starts main dispatch server
"""
allowed_domains = []
opts = docopt(__doc__, version="0.0.1")
logging.basicConfig(level=getattr(logging, opts.pop('loglevel')))
r.set_loop_type("asyncio")
with suppress(KeyError):
allowed_domains = opts.pop('allowed_domains').split(',')
allowed_domains = [a.strip() for a in allowed_domains]
app = web.Application()
app['rethinkdb'] = opts
default_opts = aiohttp_cors.ResourceOptions(
allow_credentials=True, expose_headers="*", allow_headers="*")
cors = aiohttp_cors.setup(app, defaults={
dom: default_opts for dom in allowed_domains})
cors.add(cors.add(app.router.add_resource('/')).add_route('*', Dispatcher))
cors.add(cors.add(app.router.add_resource('/ws')).add_route('*', wshandle))
web.run_app(app)
def setup(self, config):
"""
Setups the database configuartion and sets the RethinkDB loop type to
asyncio to be compatible with aiohttp.
"""
r.set_loop_type("asyncio")
self.config = config
async def connect_to_rethinkdb(self):
"""Create our connection to rethinkdb. This is what we use for storing user locations.
This will create the table and stuff if necessary"""
if r is not None:
r.set_loop_type("asyncio")
print("connecting to rethinkdb....")
if 'rethinkdb' not in self.bot.api_keys:
print(
"Looks like you don't have a rethinkdb password specified in the api key file."
)
print_why_rethinkdb()
print("Good, had password in api key file")
self.conn = await r.connect("localhost",
RETHINKDB_PORT,
user='******',
password=self.bot.api_keys['rethinkdb'])
print("Connected to rethinkdb")
try:
tables = await r.db("lamp").table_list().run(self.conn)
except r.errors.ReqlOpFailedError:
await r.db_create("lamp").run(self.conn)
await r.db("lamp").table_create("user_locations").run(self.conn)
print("Created db and table for lamp user location registration")
else:
if "user_locations" not in tables:
await r.db("lamp").table_create("user_locations").run(self.conn
)
print("Created table for lamp user location registration")
async def create_connection():
"""Create a new connection to RethinkDB for async interactions."""
env = Env()
r.set_loop_type("asyncio")
connection = await r.connect(host=env("DB_HOST"),
port=env("DB_PORT"),
db=env("DB_NAME"))
return connection
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.conn = None
r.set_loop_type("asyncio")
self.register_listener(self._connect_rethinkdb, "before_server_start")
self.search = None
self.websocket_manager = None
self.version_cache = None
def initialize(self):
app = self.application
if app.conn is None:
host = app.rethinkdb_host
port = app.rethinkdb_port
db = app.rethinkdb_db
rethinkdb.set_loop_type("tornado")
app.conn = rethinkdb.connect(host=host, port=port, db=db)
def __init__(self, *args, **kwargs):
super(ConnectBot, self).__init__(*args, **kwargs)
self.credentials = credentials
r.set_loop_type('gevent')
self.rethink = r.connect(host=self.credentials['rethink_db']['ip'], port=self.credentials['rethink_db']['port'],
password=self.credentials['rethink_db']['password'], db='connect')
self.connect_py = connect.Client()
self.up_time = datetime.datetime.utcnow()
self.process = psutil.Process()
def main():
""" Async main method. It needed to be async due to r.connect is async . """
parse_command_line()
db_name = "engine"
setup_db(db_name)
r.set_loop_type("tornado")
db = yield r.connect("localhost", db=db_name)
http_server = httpserver.HTTPServer(EngineApp(db))
http_server.listen(options.port)
def get_db_conn():
"""Yields a RethinkDB connection"""
r.set_loop_type("tornado")
try:
conn = r.connect(host=RETHINK_HOST,
port=RETHINK_PORT,
db=DB_NAME)
except r.RqlRuntimeError:
conn = r.connect(host=RETHINK_HOST, port=RETHINK_PORT)
return conn
async def open_connections(app):
LOGGER.warning('opening database connection')
r.set_loop_type('asyncio')
app.config.DB_CONN = await r.connect(host=app.config.DB_HOST,
port=app.config.DB_PORT,
db=app.config.DB_NAME)
app.config.VAL_CONN = Connection(app.config.VALIDATOR_URL)
LOGGER.warning('opening validator connection')
app.config.VAL_CONN.open()
def main():
""" Async main method. It needed to be async due to r.connect is async . """
parse_command_line()
db_name = "rechat"
setup_db(db_name)
r.set_loop_type("tornado")
db = yield r.connect("localhost", db=db_name)
#Single db connection for everything thanks a lot Ben and Jeese
http_server = httpserver.HTTPServer(RechatApp(db))
http_server.listen(options.port)
def main():
""" Async main method. It needed to be async due to r.connect is async . """
parse_command_line()
db_name = "rechat"
setup_db(db_name)
r.set_loop_type("tornado")
db = yield r.connect("localhost", db=db_name)
#Single db connection for everything thanks a lot Ben and Jeese
http_server = httpserver.HTTPServer(RechatApp(db))
http_server.listen(options.port)
def connect():
try :
r.set_loop_type("tornado")
return r.connect(host=Config.rethinkdb["host"], port=Config.rethinkdb["port"], db=Config.rethinkdb['db'])
except r.RqlDriverError :
logger.error("Can't connect to RethinkDB")
raise SystemExit("Can't connect to RethinkDB")
async def open_connections(app):
logging.debug("Tryng to initialise db")
r.set_loop_type('asyncio')
result = await r.connect(port=app.config.DATABASE["port"],
host=app.config.DATABASE["ip"],
db=app.config.DATABASE["dbname"],
user=app.config.DATABASE["user"],
password=app.config.DATABASE["password"])
#app.config.VAL_CONN = Connection(app.config.VALIDATOR_URL)
#app.config.VAL_CONN.open()
logging.debug("Rethinkdb connection made")
return result
async def open_connections(app):
LOGGER.warning('opening database connection')
r.set_loop_type('asyncio')
app.config.DB_CONN = await r.connect(
host=app.config.DB_HOST,
port=app.config.DB_PORT,
db=app.config.DB_NAME)
app.config.VAL_CONN = Connection(app.config.VALIDATOR_URL)
LOGGER.warning('opening validator connection')
app.config.VAL_CONN.open()
async def remove_content(table, key):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).get(key).delete().run(conn)
except r.ReqlOpFailedError:
result = {}
pass
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('deleted', 0) > 0
async def replace_content(table, content, key):
# This method is here because .replace and .update can have some different functionalities
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).get(key).replace(content).run(conn)
except r.ReqlOpFailedError:
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('replaced', 0) > 0 or result.get('unchanged', 0) > 0
async def remove_content(table, key):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).get(key).delete().run(conn)
except r.ReqlOpFailedError:
result = {}
pass
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('deleted', 0) > 0
async def filter_content(table: str, r_filter):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
cursor = await r.table(table).filter(r_filter).run(conn)
content = await _convert_to_list(cursor)
if len(content) == 0:
content = None
except (IndexError, r.ReqlOpFailedError):
content = None
await conn.close()
return content
async def replace_content(table, content, key):
# This method is here because .replace and .update can have some different functionalities
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).get(key).replace(content).run(conn)
except r.ReqlOpFailedError:
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('replaced', 0) > 0 or result.get('unchanged', 0) > 0
async def filter_content(table: str, r_filter):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
cursor = await r.table(table).filter(r_filter).run(conn)
content = await _convert_to_list(cursor)
if len(content) == 0:
content = None
except (IndexError, r.ReqlOpFailedError):
content = None
await conn.close()
return content
async def remove_content(table, r_filter=None):
if r_filter is None:
r_filter = {}
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).filter(r_filter).delete().run(conn)
except r.ReqlOpFailedError:
result = {}
pass
await conn.close()
if table == 'prefixes' or table == 'custom_permissions':
loop.create_task(cache[table].update())
return result.get('deleted', 0) > 0
def main():
define("port", default=8080, help="bind to this port", type=int)
define("listen", default="127.0.0.1", help="listen address", type=str)
define("debug", default=False, help="debug", type=bool)
define("rethinkdb_host",
default="localhost",
help="rethinkdb hostname",
type=str)
define("rethinkdb_db",
default="",
help="rethinkdb default database",
type=str)
tornado.options.parse_command_line()
applicaton = Application()
http_server = tornado.httpserver.HTTPServer(applicaton, xheaders=True)
http_server.listen(options.port, address=options.listen)
# Setup signal handlers
signal.signal(signal.SIGINT,
lambda sig, frame: ioloop.add_callback_from_signal(exit))
signal.signal(signal.SIGTERM,
lambda sig, frame: ioloop.add_callback_from_signal(exit))
atexit.register(shutdownHandler)
# Setup logging
my_log_format = '%(color)s%(asctime)s %(levelname)1.1s [%(module)s:%(lineno)d]%(end_color)s %(message)s'
my_log_formatter = LogFormatter(fmt=my_log_format,
datefmt='%Y-%m-%d %H:%H:%S',
color=False)
for handler in logging.getLogger().handlers:
handler.setFormatter(my_log_formatter)
try:
_conn = r.connect(options.rethinkdb_host, 28015, options.rethinkdb_db)
except: # pylint: disable=bare-except
logging.error("Could not connect to rethinkdb on host '%s'",
options.rethinkdb_host,
exc_info=False)
sys.exit(1)
# Fire up our server
logging.info('Server started on %s:%d', options.listen, options.port)
r.set_loop_type("tornado")
ioloop.start()
def __init__(self, loop_type: str = "gevent"):
self.host = os.environ.get("RETHINKDB_HOST", "127.0.0.1")
self.port = os.environ.get("RETHINKDB_PORT", "28016")
self.database = os.environ.get("RETHINKDB_DATABASE", "pythondiscord")
self.log = logging.getLogger()
self.conn = None
rethinkdb.set_loop_type(loop_type)
with self.get_connection(connect_database=False) as conn:
try:
rethinkdb.db_create(self.database).run(conn)
self.log.debug(f"Database created: '{self.database}'")
except rethinkdb.RqlRuntimeError:
self.log.debug(f"Database found: '{self.database}'")
async def replace_content(table, content, r_filter=None):
# This method is here because .replace and .update can have some different functionalities
if r_filter is None:
r_filter = {}
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
result = await r.table(table).filter(r_filter).replace(content).run(
conn)
except r.ReqlOpFailedError:
await conn.close()
result = {}
await conn.close()
if table == 'prefixes' or table == 'custom_permissions':
loop.create_task(cache[table].update())
return result.get('replaced', 0) > 0 or result.get('unchanged', 0) > 0
async def update_content(table, content, key):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
# This method is only for updating content, so if we find that it doesn't exist, just return false
try:
# Update based on the content and filter passed to us
# rethinkdb allows you to do many many things inside of update
# This is why we're accepting a variable and using it, whatever it may be, as the query
result = await r.table(table).get(key).update(content).run(conn)
except r.ReqlOpFailedError:
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('replaced', 0) > 0 or result.get('unchanged', 0) > 0
async def get_content(table: str, r_filter=None):
if r_filter is None:
r_filter = {}
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
cursor = await r.table(table).filter(r_filter).run(conn)
content = await _convert_to_list(cursor)
if len(content) == 0:
content = None
except (IndexError, r.ReqlOpFailedError):
content = None
await conn.close()
if table == 'prefixes' or table == 'custom_permissions':
loop.create_task(cache[table].update())
return content
async def update_content(table, content, key):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
# This method is only for updating content, so if we find that it doesn't exist, just return false
try:
# Update based on the content and filter passed to us
# rethinkdb allows you to do many many things inside of update
# This is why we're accepting a variable and using it, whatever it may be, as the query
result = await r.table(table).get(key).update(content).run(conn)
except r.ReqlOpFailedError:
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('replaced', 0) > 0 or result.get('unchanged', 0) > 0
async def _get_content(key: str):
# We need to make sure we're using asyncio
r.set_loop_type("asyncio")
# Just connect to the database
conn = await r.connect(**db_opts)
# We should only ever get one result, so use it if it exists, otherwise return none
try:
cursor = await r.table(key).run(conn)
await conn.close()
items = list(cursor.items)[0]
except (IndexError, r.ReqlOpFailedError):
await conn.close()
return {}
# Rethink db stores an internal id per table, delete this and return the rest
del items['id']
return items
def setup():
conn = r.connect(RDB_HOST, RDB_PORT)
def safe_run(rql):
try:
return rql.run(conn)
except r.RqlRuntimeError:
return False
print("database init db and tables")
safe_run(r.db_create(RDB_NAME))
safe_run(r.db(RDB_NAME).table_create("tasks", primary_key='id'))
safe_run(r.db(RDB_NAME).table_create('devices', primary_key='id'))
print("database init done")
conn.close()
r.set_loop_type('tornado')
def start(self):
''' Start the event loop. '''
self._logger.info('Starbelly is starting...')
r.set_loop_type('asyncio')
sys.excepthook = async_excepthook
loop = asyncio.get_event_loop()
self._main_task = asyncio.ensure_future(self.run())
loop.run_until_complete(self._main_task)
# Check if any tasks weren't properly cleaned up.
tasks = [t for t in asyncio.Task.all_tasks() if not t.done()]
if len(tasks) > 0:
self._logger.error('There are %d unfinished tasks: %r',
len(tasks), tasks)
loop.close()
self._logger.info('Starbelly has stopped.')
async def add_content(table, content):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
# First we need to make sure that this entry doesn't exist
# For all rethinkDB cares, multiple entries can exist with the same content
# For our purposes however, we do not want this
try:
result = await r.table(table).insert(content).run(conn)
except r.ReqlOpFailedError:
# This means the table does not exist
await r.table_create(table).run(conn)
await r.table(table).insert(content).run(conn)
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('inserted', 0) > 0
async def add_content(table, content):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
# First we need to make sure that this entry doesn't exist
# For all rethinkDB cares, multiple entries can exist with the same content
# For our purposes however, we do not want this
try:
result = await r.table(table).insert(content).run(conn)
except r.ReqlOpFailedError:
# This means the table does not exist
await r.table_create(table).run(conn)
await r.table(table).insert(content).run(conn)
result = {}
await conn.close()
if table == 'server_settings':
loop.create_task(cache[table].update())
return result.get('inserted', 0) > 0
async def init(cls,
scheme,
create_scheme=True,
loop_type="asyncio",
event_loop=False):
r.set_loop_type(loop_type)
if event_loop:
asyncio.set_event_loop(event_loop)
self = Thinker()
self.db = await r.connect(host=scheme['host'],
db=scheme['db'],
port=scheme['port'])
if create_scheme:
await initiator.create_tables(scheme=scheme, connection=self.db)
return self
def main():
global conn
tornado.options.options.parse_command_line()
r.set_loop_type('tornado')
conn = yield r.connect(host='127.0.0.1', db='gec')
settings = {
'static_path': os.path.join(os.path.dirname(__file__), 'static'),
'template_path': os.path.join(os.path.dirname(__file__), 'templates'),
}
application = tornado.web.Application([
(r'/', IndexHandler),
(r'/course', CourseHandler),
(r'/course/(\w{8}-\w{4}-\w{4}-\w{4}-\w{12})', CourseDetailHandler),
(r'/course/(\w{8}-\w{4}-\w{4}-\w{4}-\w{12})/page/(\d+)', CourseDetailPageHandler),
(r'/about', AboutHandler),
(r'/static/(.*)', tornado.web.StaticFileHandler, {'path': 'static'}),
], **settings)
application.listen(tornado.options.options.port, '127.0.0.1', xheaders=True)
def get(self, *args):
self.finish()
id = self.get_argument("id")
value = self.get_argument("value")
#value = 400
#print(self.get_body_argument("balkanbox", default=None, strip=False))
#subItem = "flask"
print(value)
#print("set loop")
r.set_loop_type("tornado")
print("connect")
conn = r.connect('35.166.62.31', 28015, db='poeapi')
#print(conn)
connection = yield conn
print("getting cursor")
cursor = yield r.table('itemList').filter(
lambda doc: doc['itemName'].match("(?i)" + value)).filter(
(r.row["price"] < 999)
& (r.row["price"] > 0)).changes(squash=True).run(connection)
#cursor = yield r.table('itemList').filter((r.row["price"] < 999) & (r.row["price"] > 0)).changes().run(connection)
print("prepare to loop")
while (yield cursor.fetch_next()):
item = yield cursor.next()
item = item["new_val"]
#print(item)
#time.sleep(1)
tempSTD = 0
avg = 0
itemPrice = 9999
try:
tempItem = yield r.table('lookUp').get(
item['itemName']).run(connection)
tempSTD = tempItem["STD"]
avg = tempItem["avgPrice"]
itemPrice = item["price"]
except:
print('error getting price')
if (itemPrice <= avg - tempSTD):
#print(item)
data = {"id": id, "value": json.dumps(item)}
data = json.dumps(data)
for c in cl:
c.write_message(data)
def cmd_debug(self, *args):
"""
Comando 'debug', responsável por iniciar o servidor de desenvolvimento.
"""
port = int(args[0]) if args else self.port
ServerLog.info(code='dev_server_starting', args=[port])
app = Application(routers, debug=True, autoreload=False,
cookie_secret=config('SECRET_KEY'),
login_url='/api/v1/usuarios/entrar/',
xsrf_cookies=False)
app.listen(port)
r.set_loop_type('tornado')
ioloop = IOLoop.current()
ioloop.add_callback(
callback=ServerLog.info,
code='server_started',
args=[self.host, port]
)
ioloop.start()
def __init__(self, **kwargs):
logging.basicConfig(level=logging.INFO)
r.set_loop_type("asyncio")
if "shard_count" not in kwargs:
kwargs['shard_count'] = os.environ.get("SHARD_COUNT")
if "shard_ids" not in kwargs:
kwargs['shard_ids'] = int_list_or_none(os.environ.get("SHARD_IDS"))
kwargs['command_prefix'] = os.environ.get("COMMAND_PREFIX") or "h!"
super().__init__(**kwargs)
self.remove_command("help")
self.logger = logging.getLogger("highlightpy.core.client")
self.logger.info("Creating the RethinkDB connection.")
self.rethink_connection = loop.run_until_complete(
self._get_rethink_connection())
self.token = os.environ['BOT_TOKEN']
self.logger.info("Checking the database/tables.")
loop.run_until_complete(create_tables(self.rethink_connection))
async def db_check():
"""Used to check if the required database/tables are setup"""
db_opts = config.db_opts
r.set_loop_type('asyncio')
# First try to connect, and see if the correct information was provided
try:
conn = await r.connect(**db_opts)
except r.errors.ReqlDriverError:
print(
"Cannot connect to the RethinkDB instance with the following information: {}"
.format(db_opts))
print(
"The RethinkDB instance you have setup may be down, otherwise please ensure you setup a"
" RethinkDB instance, and you have provided the correct database information in config.yml"
)
quit()
return
# Get the current databases and check if the one we need is there
dbs = await r.db_list().run(conn)
if db_opts['db'] not in dbs:
# If not, we want to create it
print('Couldn\'t find database {}...creating now'.format(
db_opts['db']))
await r.db_create(db_opts['db']).run(conn)
# Then add all the tables
for table, key in required_tables.items():
print("Creating table {}...".format(table))
await r.table_create(table, primary_key=key).run(conn)
print("Done!")
else:
# Otherwise, if the database is setup, make sure all the required tables are there
tables = await r.table_list().run(conn)
for table, key in required_tables.items():
if table not in tables:
print("Creating table {}...".format(table))
await r.table_create(table, primary_key=key).run(conn)
print("Done checking tables!")
def cmd_serve(self, *args):
"""
Comando 'serve', responsável por iniciar o servidor de produção.
"""
port = int(args[0]) if args else self.port
ServerLog.info(code='dev_server_starting', args=[port])
app = Application(
routers, cookie_secret=config('SECRET_KEY'),
login_url='/api/v1/usuarios/entrar/',
xsrf_cookies=False)
sockets = netutil.bind_sockets(port)
process.fork_processes(self.fork_processes)
server = HTTPServer(app)
server.add_sockets(sockets)
r.set_loop_type('tornado')
ioloop = IOLoop.current()
ioloop.add_callback(
callback=ServerLog.info,
code='server_started',
args=[self.host, port]
)
ioloop.start()
def listen_payments():
import rethinkdb as r
r.set_loop_type('tornado')
print('Entering listen_payments')
global play_until
b = Bigchain()
conn = yield b.conn
feed = yield r.table('bigchain').changes().run(conn)
while (yield feed.fetch_next()):
block = yield feed.next()
if not block['old_val']:
coins = get_coin_from_block(block['new_val'])
update_shares(block['new_val'])
if coins:
print('received coins')
if time.time() > play_until:
play_until = time.time() + 10 * len(coins)
else:
play_until += 10 * len(coins)
else:
get_coin_shares_from_block(block['new_val'])
async def get_content(table, key=None):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
if key:
cursor = await r.table(table).get(key).run(conn)
else:
cursor = await r.table(table).run(conn)
if cursor is None:
content = None
elif type(cursor) is not dict:
content = await _convert_to_list(cursor)
if len(content) == 0:
content = None
else:
content = cursor
except (IndexError, r.ReqlOpFailedError):
content = None
await conn.close()
return content
def listen_payments():
import rethinkdb as r
r.set_loop_type('tornado')
print('Entering listen_payments')
global play_until
b = Bigchain()
conn = yield b.conn
feed = yield r.table('bigchain').changes().run(conn)
while (yield feed.fetch_next()):
block = yield feed.next()
if not block['old_val']:
coins = get_coin_from_block(block['new_val'])
update_shares(block['new_val'])
if coins:
print('received coins')
if time.time() > play_until:
play_until = time.time() + 10 * len(coins)
else:
play_until += 10 * len(coins)
else:
get_coin_shares_from_block(block['new_val'])
async def get_content(table, key=None):
r.set_loop_type("asyncio")
conn = await r.connect(**db_opts)
try:
if key:
cursor = await r.table(table).get(key).run(conn)
else:
cursor = await r.table(table).run(conn)
if cursor is None:
content = None
elif type(cursor) is not dict:
content = await _convert_to_list(cursor)
if len(content) == 0:
content = None
else:
content = cursor
except (IndexError, r.ReqlOpFailedError):
content = None
await conn.close()
return content
def init_db(app):
rethinkdb.set_loop_type('gevent')
db.init_app(app)
async def prepare():
global connection
r.set_loop_type('asyncio')
connection = await r.connect(host="localhost", port=28015)
import rethinkdb
rethinkdb.set_loop_type("asyncio")
__version__ = "0.2.2-pre"
# constants
ALL = 0
DECLARED_ONLY = 1
UNDECLARED_ONLY = 2
from .errors import *
from .db import *
from .values_and_valuetypes import *
from .field import *
from .document import *
import rethinkdb as r
from logbook import error
r.set_loop_type('asyncio')
def make_rdb_connection(config):
try:
db_config = config['database']
args = dict(db_config.items())
args.update({
'host': db_config['host'],
'port': db_config.get('port', 28015),
'db': db_config.get('db', 'iron-strategy')
})
return r.connect(**args)
except KeyError as e:
error('Config error: could not find key: {}'.format(e))
except Exception as e:
error('Could not establish the database connection: {}'.format(e))
import functools
import os
import logging
from tornado import websocket, web, ioloop
from tornado.gen import coroutine
import rethinkdb as r
from init_accounts import get_bigchain
clients = []
bigchain = get_bigchain()
# from http://blog.hiphipjorge.com/django-and-realtime-using-django-with-tornado-and-rethinkdb/
r.set_loop_type('tornado')
logger = logging.getLogger('tornado')
@coroutine
def print_changes(db_table):
conn = yield bigchain.conn
feed = yield r.table(db_table).changes().run(conn)
while (yield feed.fetch_next()):
change = yield feed.next()
block = get_block_from_change(change, db_table)
for client in clients:
for tx in block:
# TODO: use REQL for filtering
def __init__(self, bot):
self.bot = bot
self.db_name = self.bot.config.rname
self.db = None
r.set_loop_type("asyncio")
self.ready = False
#!/usr/bin/python3.5
# -*- coding: utf-8 -*-
"""
ATTEMPT TO TEST A SIMPLE AIOHTTP ASYNCIO API SERVER (without AUTOBAHN).
"""
import asyncio
import json
import rethinkdb as r
from aiohttp import web
from datetime import datetime
from rethinkdb.errors import ReqlOpFailedError
from uuid import uuid4
r.set_loop_type("asyncio")
def create_db_and_table():
try:
r.db_create('ep16').run(conn)
except ReqlOpFailedError:
pass
try:
r.db('ep16').table_create('scores').run(conn)
except ReqlOpFailedError:
pass
def json_default(obj):
if isinstance(obj, datetime):
return obj.strftime('%Y%m%dT%H:%M:%S+00:00')
def connect():
r.set_loop_type("asyncio")
r.connect('192.168.99.100', 32769).repl()
def __init__(self, *args, **kwargs):
super(RethinkdbDiscoveryPolicy, self).__init__(*args, **kwargs)
self.feed_table = kwargs.get(u'feed_table', u'feed')
self.change_key = kwargs.get(u'change_key', u'new_val')
rethinkdb.set_loop_type(u"tornado")
import rethinkdb as r
from tornado import ioloop, gen
from search import handle_query
from utils import get_dt
r.set_loop_type("tornado")
def changed_keys(change):
ck = []
new_val = change.get('new_val', {})
if not new_val:
new_val = {}
old_val = change.get('old_val', {}) # ugh default = {} not working
if not old_val:
old_val = {}
for key in new_val:
print 'old_val', old_val
if not key in old_val:
ck.append(key)
elif change['new_val'][key] != change['old_val'][key]:
ck.append(key)
for key in old_val:
print 'new_val', new_val
if not key in change.get('new_val', {}):
ck.append(key)
elif change['new_val'][key] != change['old_val'][key]:
ck.append(key)
return list(set(ck))
@gen.coroutine
def update_row_counts(table):
conn = yield r.connect(host="localhost", port=28015)
def __init__(self, connData, sensors):
super(RDBReader, self).__init__()
self.sensors = sensors
rdb.set_loop_type('tornado')
#self.conn = rdb.connect(host=connData["host"], port=connData["port"], db=connData["db"], auth_key=connData["auth_key"])
self.conn = rdb.connect(host=connData["host"], port=connData["port"], db=connData["db"])
