def setup_database():
r = RethinkDB()
r.connect(host='localhost', port=28015).repl()
try:
# Create databases
r.db_create('platform').run()
# Create tables
r.db('platform').table_create('videos', primary_key='video_id').run()
except Exception as e:
print('Database is already setup')
else:
print('Database setup successful')
def runMe():
questions = [{
'type': 'input',
'message': 'Enter server IP',
'name': 'serverIP',
'default': 'pavela.net'
}, {
'type': 'input',
'message': 'Enter your username',
'name': 'username',
}]
answers = prompt(questions)
serverIP = answers['serverIP']
yourUserName = answers['username']
r1 = RethinkDB()
r2 = RethinkDB()
def checkMessages():
r1.connect(serverIP, 28015).repl()
cursor = r1.table("chat").changes().run()
for document in cursor:
username = document['new_val']['username']
message = document['new_val']['message']
print(Style.BRIGHT + Fore.YELLOW +
"[{username}]: ".format(username=username) +
Style.RESET_ALL + "{message}".format(message=message))
checkThread = threading.Thread(target=checkMessages)
checkThread.start()
# To stop thread: checkThread.join()
questions = [
{
'type': 'input',
'message': '>',
'name': 'yourMessage',
},
]
while True:
answers = prompt(questions)
yourMessage = answers['yourMessage']
sys.stdout.write("\033[F") # Clears the text above
r2.connect(serverIP, 28015).repl()
r2.table('chat').insert([{
"username": yourUserName,
"message": yourMessage
}]).run()
class Iface:
def __init__(self, host="127.0.0.1", port=28015, db="arcos"):
self.r = RethinkDB()
self.conn = self.r.connect(host=host, port=port, db=db)
def clear_table(self, table: str):
self.r.table(table).delete().run(self.conn)
def create_table(self, table: str) -> bool:
try:
self.r.table_create(table).run(self.conn)
return True
except ReqlOpFailedError:
return False
def get_by_uid(self, table: str, uid_name: str, uid_value: str) -> object:
cursor = self.r.table(table).filter(self.r.row[uid_name] == uid_value).run(self.conn)
for document in cursor:
return document
return None
def insert(self, table: str, uid_name: str, uid_value: str, data: object) -> bool:
if self.get_by_uid(table, uid_name, uid_value):
return False
data[uid_name] = uid_value
self.r.table(table).insert(data).run(self.conn)
return True
def update(self, table: str, uid_name: str, uid_value: str, data: object) -> bool:
if not self.get_by_uid(table, uid_name, uid_value):
self.insert(table, uid_name, uid_value, data)
return True
self.r.table(table).filter(self.r.row[uid_name] == uid_value).update(data).run(self.conn)
def test_flow_couroutine_paradigm():
r = RethinkDB()
r.set_loop_type("asyncio")
connection = yield from r.connect(os.getenv("REBIRTHDB_HOST"))
try:
yield from r.db_create(INTEGRATION_TEST_DB).run(connection)
except ReqlRuntimeError:
pass
connection.use(INTEGRATION_TEST_DB)
yield from r.table_create("marvel").run(connection)
marvel_heroes = r.table('marvel')
yield from marvel_heroes.insert({
'id': 1,
'name': 'Iron Man',
'first_appearance': 'Tales of Suspense #39'
}).run(connection)
cursor = yield from marvel_heroes.run(connection)
while (yield from cursor.fetch_next()):
hero = yield from cursor.__anext__()
assert hero['name'] == 'Iron Man'
yield from connection.close()
class BaneSensor:
def __init__(self, ip='localhost', bane_navn='Rink A'):
self.bane_navn = bane_navn
self.r = RethinkDB()
self.conn = self.r.connect(ip, 28015)
def oppdater_sensordata(self, temperatur, luftfuktighet, count=0):
try:
self.r.db(db_navn).table(status_tabell_navn).filter({
'bane':
self.bane_navn
}).update({
'luftfuktighet': luftfuktighet,
'temperatur': temperatur,
}).run(self.conn)
except:
if (count <= 20):
count += 1
self.oppdater_sensordata(temperatur, luftfuktighet, count)
else:
print(
f'{self.bane_navn}: Feilet med å laste opp data til databasen'
)
print(f'{self.bane_navn}: Sensordata oppdatert')
class DB():
def __init__(self):
self.dbname = APP_CONFIG['DB']['DB_NAME']
self.tbmovie = 'movies'
self.r = RethinkDB()
try:
self.conn = self.r.connect(host=APP_CONFIG['DB']['DB_HOST'],
db=APP_CONFIG['DB']['DB_NAME'],
user=APP_CONFIG['DB']['DB_USER'],
password=APP_CONFIG['DB']['DB_PASS'],
port=APP_CONFIG['DB']['DB_PORT'])
self.create_db()
except Exception as ex:
print('DB_ERROR', ex)
def create_db(self):
if not self.r.db_list().contains(self.dbname).run(self.conn):
self.r.db_create(self.dbname).run(self.conn)
def create_table(self):
if not self.r.db(self.dbname).table_list().contains(self.tbmovie).run(
self.conn):
self.r.db(self.dbname).table_create(self.tbmovie).run(self.conn)
def get_conn(self):
return self.conn
def get_r(self):
return self.r
def connection(self):
r = RethinkDB()
try:
conn = r.connect(host=self.RDB_HOST, port=self.RDB_PORT)
return conn
except RqlDriverError as e:
raise
class RDB:
def __init__(self):
self.dbname = "DB"
self.r = RethinkDB()
self.connection = self.r.connect("127.0.0.1", "28015").repl()
self.connection.use(self.dbname)
self._init_db()
def _init_db(self):
if not self.dbname in self.r.db_list().run(self.connection):
self.r.db_create(self.dbname).run(self.connection)
tables = self.r.table_list().run(self.connection)
if "meta" not in tables:
# table with meta data independant of each blockchain
self.r.table_create("meta", primary_key="key").run(self.connection)
if "accounts" not in tables:
# address table
self.r.table_create("accounts",
primary_key="account_id").run(self.connection)
if "pseudo_ids" not in tables:
# table for pseudo_ids for mapping back-end wallets to front-end user
self.r.table_create("pseudo_ids").run(self.connection)
if "transactions" not in tables:
# transaction table
self.r.table_create("transactions",
primary_key="operation_id").run(
self.connection)
def auto(member: Type[Model]):
"""Automatic database and table creation for the given type (Modelchild)."""
if not issubclass(member, Model) or member is Model:
return
rdb = RethinkDB()
conn = rdb.connect(
host=db.HOST,
port=db.PORT,
db=db.DB_NAME,
user=db.USER,
password=db.PASSWORD,
ssl=db.SSL,
timeout=db.TIMEOUT,
)
tables = rdb.table_list().run(conn)
if member.tablename not in tables:
LOG.info("create table %s", member.tablename)
rdb.table_create(member.tablename).run(conn)
indexes = member.get_indexes()
if indexes:
# TODO: at this time, it's only working with simple index
for index in indexes:
rdb.table(member.tablename).index_create(index).run(conn)
rdb.table(member.tablename).index_wait(index).run(conn)
conn.close()
class Database:
def __init__(self, host, port, user, password, db):
self.host = host
self.port = port
self.user = user
self.password = password
self.db = db
self.r = RethinkDB()
self.conn = None
def query_results(self, query):
"""
queries the database for games matching the given string
"""
results = []
if query == "":
return results
# query for products
self.connect()
cursor = self.r.table('products').filter(
(self.r.row["app_name"].match("(?i)" + query))
& (self.r.row["is_dlc"] == False)).limit(20).run(self.conn)
# build result array
for item in cursor:
if item is not None:
results.append(item)
# close the database connection
self.teardown()
return results
def connect(self):
"""
opens a new connection to the database
"""
try:
# connect to the database
self.conn = self.r.connect(
host=self.host,
port=self.port,
db=self.db,
user=self.user,
password=self.password,
)
except RqlDriverError:
abort(503, "No database connection could be established.")
def teardown(self):
"""
closes an open connection to the database
"""
try:
self.conn.close()
except AttributeError:
pass
def main():
argument_spec = dict(
host=dict(required=True),
port=dict(required=False, type=int, default=28015),
user=dict(required=False, default="admin"),
password=dict(required=False, default="", no_log=True),
ssl=dict(required=False, type=dict, default=None),
table=dict(
required=False,
choices=[
"table_config",
"server_config",
"db_config",
"cluster_config",
"table_status",
"server_status",
"current_issues",
"users",
"permissions",
"jobs",
"stats",
"logs",
],
default="server_status",
),
limit=dict(required=False, type=int, default=10),
)
module = AnsibleModule(
argument_spec=argument_spec,
)
client = RethinkDB()
_params = {
"host": module.params["host"],
"port": module.params["port"],
"user": module.params["user"],
"password": module.params["password"],
"ssl": module.params["ssl"],
"db": "rethinkdb",
}
__res = []
try:
conn = client.connect(**_params)
_res = (
client.table(module.params["table"]).limit(module.params["limit"]).run(conn)
)
while True:
try:
__res.append(_res.next())
except DefaultCursorEmpty:
break
module.exit_json(result=__res)
except (ReqlAuthError, ReqlOpFailedError) as e:
module.fail_json(msg=e.message)
finally:
conn.close(noreply_wait=False)
def execute_query(module):
results = list()
try:
r = RethinkDB()
r.connect(host=module.params.get('host'),
port=module.params.get('port'),
user=module.params.get('user'),
password=module.params.get('password')).repl()
query_result = eval("r.{0}.run()".format(module.params.get('query')))
if type(query_result) is dict:
results.append(query_result)
else:
for document in query_result:
results.append(document)
return results
except Exception as e:
module.fail_json(msg="Error: {0}".format(e))
class RethinkDbDatabaseConnector(DatabaseConnector):
def __init__(self):
self.r = RethinkDB()
self.conn = None
def disconnect(self):
self.conn.close()
def connect(self, hostname, port, database):
self.conn = self.r.connect(hostname, port, database)
return self.r, self.conn
class Rethinkdb:
def __init__(self):
self.__r = RethinkDB()
self.__connector = self.__r.connect(config.host, config.port, db=config.db, user=config.user, password=config.password).repl()
async def closeDB(self):
if self.__connector:
self.__connector.close()
def getR(self):
return self.__r
def setup(self):
r = RethinkDB()
self._connection = r.connect(host=self.RDB_HOST, port=self.RDB_PORT)
try:
r.db_create(self.APP_DB).run(self._connection)
print(f' * [x] Database "{self.APP_DB}" created')
except RqlRuntimeError:
print(f' * [-] Database "{self.APP_DB}" is already exist.')
finally:
self._rdb = r.db(self.APP_DB)
self._connection.close()
self.init_tables()
def test_database_creation(self):
"""Check, if :meth:rethinkmodel.manage.check_db() creates the database."""
db_name = "test_creation"
config(dbname=db_name)
check_db()
rdb = RethinkDB()
conn = rdb.connect()
dbs = rdb.db_list().run(conn)
if db_name not in dbs:
self.fail("Database named {db_name} was not created")
conn.close()
def main():
argument_spec = dict(host=dict(required=True),
port=dict(type=int, default=28015),
user=dict(default="admin"),
password=dict(default="", no_log=True),
ssl=dict(type=dict, default=None),
state=dict(choices=["present", "absent", "rename"],
default="present"),
database=dict(required=True),
table=dict(required=True),
key=dict(required=True),
new_key=dict(required=False))
module = AnsibleModule(argument_spec=argument_spec, )
client = RethinkDB()
_params = {
"host": module.params["host"],
"port": module.params["port"],
"user": module.params["user"],
"password": module.params["password"],
"ssl": module.params["ssl"],
}
try:
conn = client.connect(**_params)
if module.params["state"].lower() == "present":
_res = (client.db(module.params["database"]).table(
module.params["table"]).index_create(
module.params["key"]).run(conn))
elif module.params["state"].lower() == "rename":
_res = (client.db(module.params["database"]).table(
module.params["table"]).index_rename(
module.params["key"], module.params['new_key']).run(conn))
else:
_res = (client.db(module.params["database"]).table(
module.params["table"]).index_drop(
module.params["key"]).run(conn))
module.exit_json(changed=True, result=_res)
except ReqlOpFailedError as e:
if module.params["state"].lower(
) == "present" and "already exists" in e.message:
module.exit_json(changed=False, result=e.message)
elif module.params[
"state"] == "absent" and "does not exist" in e.message:
module.exit_json(changed=False, result=e.message)
else:
module.fail_json(msg=e.message)
except ReqlAuthError as e:
module.fail_json(msg=e.message)
finally:
conn.close(noreply_wait=False)
def main():
argument_spec = dict(
host=dict(required=True),
port=dict(required=False, type=int, default=28015),
user=dict(required=False, default="admin"),
password=dict(required=False, default="", no_log=True),
ssl=dict(required=False, type=dict, default=None),
database=dict(required=False),
list_databases=dict(required=False, type=bool),
list_database_config=dict(required=False, type=bool),
list_tables=dict(required=False, type=bool),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_if=(
("list_database_config", True, ["database"]),
("list_tables", True, ["database"]),
),
mutually_exclusive=[("list_databases", "list_database_config",
"list_tables")],
)
client = RethinkDB()
_params = {
"host": module.params["host"],
"port": module.params["port"],
"user": module.params["user"],
"password": module.params["password"],
"ssl": module.params["ssl"],
"db": "rethinkdb",
}
try:
conn = client.connect(**_params)
if module.params["list_databases"]:
_res = client.db_list().run(conn)
module.exit_json(databases=_res)
elif module.params["list_database_config"]:
_res = client.db(module.params["database"]).config().run(conn)
module.exit_json(database_config=_res)
elif module.params["list_tables"]:
_res = client.db(module.params["database"]).table_list().run(conn)
module.exit_json(tables=_res)
else:
module.fail_json("unknown options")
except (ReqlAuthError, ReqlOpFailedError) as e:
module.fail_json(msg=e.message)
finally:
conn.close(noreply_wait=False)
def searchForUser():
rethink_db = None #persistent connections attempt
print("Enter Username")
username = input()
searchby = {'username': username}
print()
# Search for users in db (if rethink is down, report a crash)
try:
if rethink_db == None:
rethink_db = RethinkDB()
rethink_db.connect("433-25.csse.rose-hulman.edu", 28015).repl()
print('search query:', searchby)
cur = list(
rethink_db.db('users').table("usertable").filter(searchby).run())
if len(cur) > 0:
for x in cur:
print(x)
return
else:
print("There are no user with that username in the system")
except Exception as e:
print("Cannot currently connect to RethinkDB:")
def __enter__(myself):
r = RethinkDB()
if not hasattr(myself, 'conn') or not myself.conn or not myself.conn.is_open():
myself.conn = r.connect(self.host, self.port, self.db, user=self.user, password=self.password)
self.log.debug(f"Connecting using connection: {myself}")
if not myself.conn.is_open():
raise Exception("Cannot open a new rethinkdb connection...")
self.log.debug(f"Repl-ing connection: {myself}")
myself.conn.repl()
return myself.conn
def init():
red = RethinkDB()
for _ in range(10):
try:
red.connect("rethink", 28015, password="").repl()
red.db_list().run()
break
except:
continue
time.sleep(2)
if red is None:
print("cannot connect to db")
exit(1)
else:
db_list = red.db_list().run()
if "test" in db_list:
red.db_drop("test").run()
for i in dbs:
if i not in db_list:
red.db_create(i).run()
for j in dbs[i]:
if j not in red.db(i).table_list().run():
red.db(i).table_create(j).run()
return red
def connect() -> Tuple[RethinkDB, Any]:
"""Return a RethinkDB object + connection.
You will usually not need to call this function. Rethink:Model use
this function to internally open and close database connection.
"""
rdb = RethinkDB()
connection = rdb.connect(
host=HOST,
port=PORT,
db=DB_NAME,
user=USER,
password=PASSWORD,
timeout=TIMEOUT,
ssl=SSL,
)
return rdb, connection
class Database(object):
def __init__(self, url):
self.r = RethinkDB()
self.conn = self.r.connect(url, 28015)
def client(self):
return self.r.db("olympus")
def get_table(self, tbl):
return self.r.db("olympus").table(tbl).run(self.conn)
def get(self, tbl, key):
return self.r.db("olympus").table(tbl).get(key).run(self.conn)
def insert(self, tbl, obj):
self.r.db("olympus").table(tbl).insert(obj, conflict="replace").run(
self.conn)
def check_db():
"""Check if DB_NAME exists, or create it."""
rdb = RethinkDB()
conn = rdb.connect(
host=db.HOST,
port=db.PORT,
user=db.USER,
password=db.PASSWORD,
ssl=db.SSL,
timeout=db.TIMEOUT,
)
dbs = rdb.db_list().run(conn)
if db.DB_NAME not in dbs:
LOG.info("create database %s", db.DB_NAME)
rdb.db_create(db.DB_NAME).run(conn)
conn.close()
class Persistence():
def __init__(self):
self.r = RethinkDB()
self.conn = self.r.connect("localhost", 28015)
def insert(self, data):
# add timestamp
mydata = copy.deepcopy(data)
mydata["time"] = int(time.time())
self.last = mydata["time"]
try:
self.r.db('makers-covid').table('global').insert(mydata).run(
self.conn)
except RqlRuntimeError as err:
print(err.message)
def getLast(self):
res = self.r.db('makers-covid').table('global').filter(
self.r.row['time'] >= self.last).run(self.conn)
return res.next()
data array is constructed in the while loop
sent to data parsing where is it mapped to the different sensors
a dictionary constructed
push data sends the dictionary to the table
"""
import serial
import time
from PythonCode.SerialReading.data_to_sent import data_sent
from rethinkdb import RethinkDB
import sys
r = RethinkDB()
try:
# conn = r.connect("sam.soon.it", 8912).repl()
conn = r.connect("localhost", 28015).repl()
except:
print("pr")
exit(0)
print("Server connected")
ARDUINO_PATH = ""
RESET_TIME = 30
DATA_LEN = 13
SYNC_TIMES = 10
synced = 0
'''
detect the OS
'''
if sys.platform.startswith('linux'):
print("Linux")
ARDUINO_PATH = '/dev/ttyACM0'
from datetime import datetime
import os
from bson import ObjectId
from rethinkdb import RethinkDB
r = RethinkDB()
app = Flask(__name__)
UPLOAD_FOLDER =os.getcwd()+"/uploads"
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
client = MongoClient('mongodb+srv://mongodb:[email protected]/house?retryWrites=true&w=majority')
db = client.Api
users = db['user']
#rethinkd config
conn = r.connect('localhost', 28015).repl()
##***************=>Default Route**********************##
@app.route('/')
def index():
return render_template('index.html')
##***************=>Users Route**********************##
@app.route("/users")
def users():
try:
user_arr = list()
user_out = db['user']
user_list = user_out.find()
for user in user_list:
user_arr.append(user)
class RethinkDBJobStore(BaseJobStore):
"""
Stores jobs in a RethinkDB database. Any leftover keyword arguments are directly passed to
rethinkdb's `RethinkdbClient <http://www.rethinkdb.com/api/#connect>`_.
Plugin alias: ``rethinkdb``
:param str database: database to store jobs in
:param str collection: collection to store jobs in
:param client: a :class:`rethinkdb.net.Connection` instance to use instead of providing
connection arguments
:param int pickle_protocol: pickle protocol level to use (for serialization), defaults to the
highest available
"""
def __init__(self, database='apscheduler', table='jobs', client=None,
pickle_protocol=pickle.HIGHEST_PROTOCOL, **connect_args):
super(RethinkDBJobStore, self).__init__()
if not database:
raise ValueError('The "database" parameter must not be empty')
if not table:
raise ValueError('The "table" parameter must not be empty')
self.database = database
self.table_name = table
self.table = None
self.client = client
self.pickle_protocol = pickle_protocol
self.connect_args = connect_args
self.r = RethinkDB()
self.conn = None
def start(self, scheduler, alias):
super(RethinkDBJobStore, self).start(scheduler, alias)
if self.client:
self.conn = maybe_ref(self.client)
else:
self.conn = self.r.connect(db=self.database, **self.connect_args)
if self.database not in self.r.db_list().run(self.conn):
self.r.db_create(self.database).run(self.conn)
if self.table_name not in self.r.table_list().run(self.conn):
self.r.table_create(self.table_name).run(self.conn)
if 'next_run_time' not in self.r.table(self.table_name).index_list().run(self.conn):
self.r.table(self.table_name).index_create('next_run_time').run(self.conn)
self.table = self.r.db(self.database).table(self.table_name)
def lookup_job(self, job_id):
results = list(self.table.get_all(job_id).pluck('job_state').run(self.conn))
return self._reconstitute_job(results[0]['job_state']) if results else None
def get_due_jobs(self, now):
return self._get_jobs(self.r.row['next_run_time'] <= datetime_to_utc_timestamp(now))
def get_next_run_time(self):
results = list(
self.table
.filter(self.r.row['next_run_time'] != None) # noqa
.order_by(self.r.asc('next_run_time'))
.map(lambda x: x['next_run_time'])
.limit(1)
.run(self.conn)
)
return utc_timestamp_to_datetime(results[0]) if results else None
def get_all_jobs(self):
jobs = self._get_jobs()
self._fix_paused_jobs_sorting(jobs)
return jobs
def add_job(self, job):
job_dict = {
'id': job.id,
'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
'job_state': self.r.binary(pickle.dumps(job.__getstate__(), self.pickle_protocol))
}
results = self.table.insert(job_dict).run(self.conn)
if results['errors'] > 0:
raise ConflictingIdError(job.id)
def update_job(self, job):
changes = {
'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
'job_state': self.r.binary(pickle.dumps(job.__getstate__(), self.pickle_protocol))
}
results = self.table.get_all(job.id).update(changes).run(self.conn)
skipped = False in map(lambda x: results[x] == 0, results.keys())
if results['skipped'] > 0 or results['errors'] > 0 or not skipped:
raise JobLookupError(job.id)
def remove_job(self, job_id):
results = self.table.get_all(job_id).delete().run(self.conn)
if results['deleted'] + results['skipped'] != 1:
raise JobLookupError(job_id)
def remove_all_jobs(self):
self.table.delete().run(self.conn)
def shutdown(self):
self.conn.close()
def _reconstitute_job(self, job_state):
job_state = pickle.loads(job_state)
job = Job.__new__(Job)
job.__setstate__(job_state)
job._scheduler = self._scheduler
job._jobstore_alias = self._alias
return job
def _get_jobs(self, predicate=None):
jobs = []
failed_job_ids = []
query = (self.table.filter(self.r.row['next_run_time'] != None).filter(predicate) # noqa
if predicate else self.table)
query = query.order_by('next_run_time', 'id').pluck('id', 'job_state')
for document in query.run(self.conn):
try:
jobs.append(self._reconstitute_job(document['job_state']))
except Exception:
self._logger.exception('Unable to restore job "%s" -- removing it', document['id'])
failed_job_ids.append(document['id'])
# Remove all the jobs we failed to restore
if failed_job_ids:
self.r.expr(failed_job_ids).for_each(
lambda job_id: self.table.get_all(job_id).delete()).run(self.conn)
return jobs
def __repr__(self):
connection = self.conn
return '<%s (connection=%s)>' % (self.__class__.__name__, connection)
def main():
argument_spec = dict(
host=dict(required=True),
port=dict(required=False, type=int, default=28015),
user=dict(required=False, default="admin"),
password=dict(required=False, default="", no_log=True),
ssl=dict(required=False, type=dict, default=None),
command=dict(required=False, choices=["rebalance", "reconfigure"]),
database=dict(required=True),
table=dict(required=False),
shards=dict(required=False, type=int),
replicas=dict(required=False, type=int),
)
module = AnsibleModule(
argument_spec=argument_spec,
)
client = RethinkDB()
_params = {
"host": module.params["host"],
"port": module.params["port"],
"user": module.params["user"],
"password": module.params["password"],
"ssl": module.params["ssl"],
"db": "rethinkdb",
}
try:
conn = client.connect(**_params)
if module.params["command"].lower() == "rebalance":
if module.params["table"] is None:
_res = client.db(module.params["database"]).rebalance().run(conn)
else:
_res = (
client.db(module.params["database"])
.table(module.params["table"])
.rebalance()
.run(conn)
)
if "rebalanced" in _res and _res["rebalanced"] > 0:
module.exit_json(changed=True, result=_res)
else:
module.exit_json(result=_res)
elif module.params["command"].lower() == "reconfigure":
if module.params["table"] is None:
_res = (
client.db(module.params["database"])
.reconfigure(
shards=module.params["shards"],
replicas=module.params["replicas"],
)
.run(conn)
)
else:
_res = (
client.db(module.params["database"])
.table(module.params["table"])
.reconfigure(
shards=module.params["shards"],
replicas=module.params["replicas"],
)
.run(conn)
)
module.exit_json(changed=True, result=_res)
except (ReqlAuthError, ReqlOpFailedError) as e:
module.fail_json(msg=e.message)
finally:
conn.close(noreply_wait=False)
def connect(self):
self._session = r.connect(self._host, self._port, self._db,
self._username, self._password,
self._timeout, self._ssl)
def experiment_rethinkdb_folded():
from rethinkdb import RethinkDB
r = RethinkDB()
conn = r.connect(db='test')
r.db_create('test_db').run(conn)
r.db_list().run(conn)
def checkLog():
mongo_db = None
rethink_db = None
if red.get(mongoLSN) == None:
red.set(mongoLSN, 0) # Latest LSN mongo has successfully run
if red.get(rethinkLSN) == None:
red.set(rethinkLSN, 0) # Latest LSN mongo has successfully run
if red.get(currLSN) == None:
red.set(currLSN, 1) #Highest LSN in the log
# Loop through
while True:
# Try to connect to Rethink if there is no connection
if rethink_db == None:
try:
rethink_db = RethinkDB()
rethink_db.connect("433-25.csse.rose-hulman.edu", 28015).repl()
except:
rethink_db = None
print("RethinkDB is down")
# Try to connect to MongoDB if there is no connection
if mongo_db == None:
try:
mongo_db = pymongo.MongoClient(
'mongodb://433-27.csse.rose-hulman.edu:40002,433-25.csse.rose-hulman.edu:40000,433-26.csse.rose-hulman.edu:40001,433-28.csse.rose-hulman.edu:40003/moviedb?replicaSet=movieapp'
)
except:
mongo_db = None
print("MongoDB is down")
m_LSN = int(red.get(mongoLSN)) # LSN mongo is currently on
r_LSN = int(red.get(rethinkLSN)) # LSN rethink is currently on
latest_LSN = int(red.get(currLSN)) - 1 #Highest LSN in the log
if mongo_db != None: #rethink_db == None
#print("RethinkDB only down")
if m_LSN <= latest_LSN:
msgs = red.zrangebyscore(log, m_LSN,
m_LSN) #returns command at lsn
if len(msgs) == 0:
red.incr(mongoLSN, 1)
continue
msg = msgs[0].decode().split(' ') #should only be one
print('Mongo Reading LSN', m_LSN, ":", msgs[0])
#run msg on mongo_db
rethinkOnlyCommands = [
'ADDUSER', 'DELUSER', 'EDITUSER', 'DELMOVIEFROMLIST'
]
if msg[0] == 'DELMOVIE':
if len(msg) < 2:
print("Bad formatted DELMOVIE log command at lsn",
m_LSN)
else:
res = delmovie(msg, mongo_db)
if res == 0:
red.incr(mongoLSN, 1)
else:
mongo_db = None
#need to delete from collections in rethinkDB
elif msg[0] == 'ADDMOVIE':
if len(msg) < 11:
print("Bad formatted ADDMOVIE log command at lsn",
m_LSN)
else:
res = addmovie(msg, mongo_db)
if res == 0: #success
red.incr(mongoLSN, 1)
else:
mongo_db = None
elif msg[0] == 'EDITMOVIE':
if len(msg) < 14:
print("Bad formatted EDITMOVIE log command at lsn",
m_LSN)
else:
res = editmovie(msg, mongo_db)
if res == 0: #success
red.incr(mongoLSN, 1)
else:
mongo_db = None
#if mongo errors, res = 1, and loop again
elif msg[
0] == 'ADDMOVIETOLIST': #Verify movie exists, else remove from log so rethink doesn't run it
print(
'Mongo will verify movie ID is valid just before adding to user list'
)
red.incr(mongoLSN, 1)
elif msg[0] in rethinkOnlyCommands: #skip and move on
print("No operation necessary for MongoDB")
red.incr(mongoLSN, 1)
else:
print("Unknown command, skipped lsn", m_LSN)
red.incr(mongoLSN, 1)
if rethink_db != None:
if r_LSN <= latest_LSN:
msgs = red.zrangebyscore(log, r_LSN,
r_LSN) #returns command at lsn
if len(msgs) == 0:
red.incr(rethinkLSN, 1)
continue
msg = msgs[0].decode().split(' ') #should only be one
print('Rethink Reading LSN', r_LSN, ":", msgs[0])
mongoOnlyCommands = ['ADDMOVIE', 'EDITMOVIE']
#have a wait variable if m_LSN < r_LSN and need mongo to do a validity search (ADDMOVIETOLIST)
if msg[0] == 'DELUSER':
if len(msg) < 2:
print("Bad formatted DELUSER log command at lsn",
r_LSN)
else:
res = deluser(msg, rethink_db)
if res == 0:
red.incr(rethinkLSN, 1)
else:
rethink_db = None
elif msg[0] == 'ADDUSER':
if len(msg) < 4:
print("Bad formatted ADDUSER log command at lsn",
r_LSN)
else:
res = adduser(msg, rethink_db)
if res == 0: #success
red.incr(rethinkLSN, 1)
else:
rethink_db = None
elif msg[0] == 'EDITUSER':
if len(msg) < 4:
print("Bad formatted EDITUSER log command at lsn",
r_LSN)
else:
res = edituser(msg, rethink_db)
if res == 0: #success
red.incr(rethinkLSN, 1)
else:
rethink_db = None
elif msg[0] == 'DELMOVIEFROMLIST':
if len(msg) < 3:
print(
"Bad formatted DELMOVIEFROMLIST log command at lsn",
r_LSN)
else:
res = delMovieFromUserList(msg, rethink_db)
if res == 0: #success
red.incr(rethinkLSN, 1)
else:
rethink_db = None
elif msg[
0] == 'ADDMOVIETOLIST': #Verify movie exists, else remove from log so rethink doesn't run it
if len(msg) < 3:
print(
"Bad formatted DELMOVIEFROMLIST log command at lsn",
r_LSN)
else:
#search for movie, if it exists, then move on
res = verifyMovie(msg, mongo_db)
if res == 0:
print("Movie ID", msg[2], "exists")
elif res == 1:
print("Movie ID", msg[2], "does not exist")
red.incr(rethinkLSN, 1) #skip it
continue
else: #mongo down - can't connect; loop until get a connection
print(
"Mongo down - cannot verify movieID is valid; Must wait for mongoDB to verify valid movie ID"
)
continue
#if movie exists, add it to user list
res = addMovieToUserList(msg, rethink_db)
if res == 0: #success
red.incr(rethinkLSN, 1)
else:
rethink_db = None
elif msg[0] == 'DELMOVIE':
if len(msg) < 2:
print("Bad formatted DELMOVIE log command at lsn",
m_LSN)
else:
res = delMovieIDFromAllLists(msg, rethink_db)
if res == 0:
red.incr(rethinkLSN, 1)
else:
mongo_db = None
elif msg[0] in mongoOnlyCommands: #skip and move on
print("No operation necessary for RethinkDB")
red.incr(rethinkLSN, 1)
else:
print("Unknown command, skipped lsn", r_LSN)
red.incr(rethinkLSN, 1)
removeMessages(m_LSN, r_LSN, latest_LSN, red)
