def post(self, request, group_id, deck_id):
c = Bucket('couchbase://localhost/nihongo')
success = 'dunno'
print('deleting deck')
try:
c.delete(deck_id)
group = c.get(group_id).value
print(group.get('decks_list'))
group.get('decks_list').remove(deck_id)
c.upsert(group_id, group)
success = 'success'
except (BaseException, CouchbaseError) as e:
success = 'error'
print(e)
group = c.get(group_id).value
group_decks = group.get('decks_list')
decks_list = []
for d in group_decks:
try:
deck = c.get(d)
decks_list.append(deck)
except CouchbaseError:
pass
return HttpResponseRedirect(reverse('tutor:group_decks', kwargs={'group_id' : group_id}))
def delete_keys(bucket, prefix, low, high):
client = Bucket(HOST + '/' + bucket)
deleted = 0
failed = 0
for i in xrange(low, high):
key = prefix + "_" + str(i)
try:
client.delete(key)
deleted = deleted + 1
except Exception as ex:
failed = failed + 1
pass
print "Deleted " + str(deleted) + " keys. Missed " + str(failed)
def delete_keys(bucket, prefix, low, high):
client = Bucket(HOST+'/'+bucket)
deleted = 0
failed = 0
for i in xrange(low, high):
key = prefix +"_"+str(i)
try:
client.delete(key)
deleted = deleted+1
except Exception as ex:
failed = failed+1
pass
print "Deleted " + str(deleted) + " keys. Missed " + str(failed)
class DB:
conn = None
db = None
def __init__(self):
self.conn = Bucket("couchbase://localhost:8091/default")
def createDB(self):
self.db = self.conn.upsert("EsParser")
def deleteDB(self):
self.conn.delete("EsParser")
def saveData(self, document):
self.conn.upsert('Frase' + str(uuid4()).replace("-", ""), document)
def getData(self):
return None
class BucketWrapper:
TIMEOUT = 120
def __init__(self, host, bucket, password, quiet=True, port=8091):
connection_string = 'couchbase://{}:{}/{}?password={}'\
.format(host, port, bucket, password)
self.client = Bucket(connection_string=connection_string, quiet=quiet)
self.client.timeout = self.TIMEOUT
self.use_count = 0
self.use_time = 0
self.last_use_time = 0
def start_using(self):
self.last_use_time = time()
def stop_using(self):
self.use_time += time() - self.last_use_time
self.use_count += 1
def query(self, ddoc, view, key):
return self.client.query(ddoc, view, key=key)
def set(self, key, doc):
self.client.set(key, doc)
def delete(self, key):
self.client.delete(key)
def upsert(self, key, doc):
self.client.upsert(key, doc)
def endure(self, key, persist_to, replicate_to, interval, timeout=120):
self.client.endure(key,
persist_to=persist_to,
replicate_to=replicate_to,
interval=interval,
timeout=timeout)
class Db(object):
def __init__(self, couchbase_sup=False, mongo_sup=False):
self.cfg = election[os.getenv("TARGET_PLATFORM")]
self.vt = None
self.mysql = None
self.connect_mysql()
if couchbase_sup:
cb_config = self.cfg.COUCHBASE_PARAM
self.cb = Bucket("couchbase://{0}/{1}".format(cb_config[0], cb_config[1]), username=cb_config[2], password=cb_config[3])
if mongo_sup:
mongo_cfg = self.cfg.MONGO_PARAM
self.mongodb_client = MongoClient(host=mongo_cfg[0], port=int(mongo_cfg[1]), username=mongo_cfg[2], password=mongo_cfg[3], authSource=mongo_cfg[4], authMechanism=mongo_cfg[5])
def connect_mysql(self):
mysql_config = self.cfg.MYSQL_PARAM
self.mysql = mdb.connect(host=mysql_config[0], user=mysql_config[1], passwd=mysql_config[2], db=mysql_config[3], port=int(mysql_config[4]))
self.mysql.autocommit(False)
self.vt = self.mysql.cursor()
def write_mysql(self, query):
try:
self.vt.execute(query)
return True
except mdb.OperationalError:
self.connect_mysql()
self.vt.execute(query)
return True
def count_mysql(self, query):
try:
self.vt.execute(query)
return self.vt.rowcount
except mdb.OperationalError:
self.connect_mysql()
self.vt.execute(query)
return self.vt.rowcount
def readt_mysql(self, query):
try:
self.vt.execute(query)
self.mysql_commit()
return self.vt.fetchall()
except mdb.OperationalError:
self.connect_mysql()
self.vt.execute(query)
self.mysql_commit()
return self.vt.fetchall()
def mysql_commit(self):
self.mysql.commit()
def mysql_rollback(self):
self.mysql.rollback()
def write_couchbase(self, arg):
key = calculate_hash(arg.keys()[0])
values = []
for i in arg.values():
if isinstance(i, str):
values.append(calculate_hash(i))
continue
if isinstance(i, list):
for e in i:
values.append(calculate_hash(e))
continue
values.append(i)
try:
self.cb.insert(key, values)
except couchbase.exceptions.KeyExistsError:
self.cb.replace(key, values)
return True
def readt_couchbase(self, key):
try:
return True, self.cb.get(calculate_hash(key)).value
except couchbase.exceptions.NotFoundError:
return False, 0
def delete_key_couchbase(self, key):
try:
self.cb.delete(calculate_hash(key), quiet=True)
except couchbase.exceptions.NotFoundError:
pass
finally:
return True
def delete(key, bucket = "default", password = ""):
cb = Bucket(host=cfg.COUCHBASE_IP + "/" + self.bucket)
rc = cb.delete(key)
from couchbase.bucket import Bucket
import sys
mb = Bucket("couchbase:///memoir")
#:print mb.get(sys.argv[1]).value
mb.delete("{\"total_rows\":76,\"rows\":[\r\n]\r\n}\n")
mb.decr('tcount')
