def gitx(request): ''' get all commits for this project for top 20 , do view call to find out the builds ''' logger = logging.getLogger('dashboard') project = request.GET.get('project') limit = request.GET.get('limit') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") cbclient= CbClient("localhost", 8091, "Administrator", "password") a,b,value = couchbase.get(project.encode('ascii','ignore')) commits = json.loads(value)["tree"] counter = 0 data = list() for commit in commits: commit["builds"]=[] counter = counter + 1 filter_value = "\"%s-%s\"" % (project, commit["revision"]) params={"startkey":filter_value,"endkey":filter_value} qr = cbclient.query(bucket='default', ddoc='builds', view='commits', limit=100,params=params) for item in qr["rows"]: logger.error(commit["builds"]) fullversion = item["value"][1].encode('ascii','ignore') if fullversion not in commit["builds"]: commit["builds"].append(fullversion) data.append(commit) end_index = commit["message"].find("\n") or len(commit["message"] - 1) commit["message"] = commit["message"][0:end_index] if counter == limit: break return render_to_response('../templates/dashboard/commits.html', {'title': 'commits', 'data': data})
class CouchbaseClientTest(Base): def setUp(self): super(CouchbaseClientTest, self).setUp() self.client = CouchbaseClient(self.url, self.bucket_name, "", True) def tearDown(self): self.client.done() @nottest def setup_memcached_bucket(self): self.memcached_bucket = 'testing-memcached' self.rest_client = RestConnection({'ip': self.host, 'port': self.port, 'username': self.username, 'password': self.password}) self.rest_client.create_bucket(self.memcached_bucket, bucketType='memcached', authType='sasl', ramQuotaMB=64) self.client_for_memcached_bucket = \ CouchbaseClient(self.url, self.memcached_bucket, verbose=True) @nottest def teardown_memcached_bucket(self): self.rest_client.delete_bucket(self.memcached_bucket) @attr(cbv="1.0.0") def test_set_integer_value(self): self.client.set('int', 0, 0, 10) self.assertEqual(self.client.get('int')[2], 10, 'value should be the integer 10') self.client.incr('int') self.assertEqual(self.client.get('int')[2], 11, 'value should be the integer 11') self.client.delete('int') def test_two_client_incr(self): """http://www.couchbase.com/issues/browse/PYCBC-16""" key = 'test_two_client_incr' client_one = self.client client_two = CouchbaseClient(self.url, self.bucket_name, "", True) # Client one sets a numeric key client_one.set(key, 0, 0, 20) # Client two tries to increment this numeric key (i, cas) = client_two.incr(key) self.assertEqual(i, 21) # Client two should be able to keep incrementing this key (i, cas) = client_two.incr(key) self.assertEqual(i, 22) (_, cas, i) = client_two.get(key) self.assertEqual(i, 22) (i, cas) = client_two.incr(key) self.assertEqual(i, 23) def test_bucket_of_type_memcached(self): self.setup_memcached_bucket() self.assertIsInstance(self.client_for_memcached_bucket, CouchbaseClient) self.teardown_memcached_bucket()
def create(self, request): logger = logging.getLogger('dashboard') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") kv_data = {} json_data = json.loads(request.raw_post_data) for object in json_data: name = json_data[object] skip_tokens = ["CHANGES", "1.7", "1.8.1r", "preview-", "-manifest"] if not RawBuildNameDecodedHelper.is_substring(skip_tokens, name): data = RawBuildNameDecodedHelper.populate_build_meta(name) kv_data[name] = data result = {} num_updated_rows = 0 for key in kv_data: item = kv_data[key] if "package" not in item or "fullversion" not in item: continue item = kv_data[key] _id = "%s-%s-%s-%s" % (item["package"], item["arch"], item["os"], item["fullversion"]) if item["package"] == "manifest": content = self._download(item["url"]) to_json = self._to_json(content, item["fullversion"]) item["commits"] = to_json couchbase.set(_id.encode("ascii", "ignore"), 0, 0, json.dumps(item).encode("ascii", "ignore")) num_updated_rows += 1 logger.info('updated %d rows in the database' % (num_updated_rows)) return {"status": "ok"}
def __init__(self, name, server): self.server = server self.name = name rest = server._rest() self.info = rest.get_bucket(self.name) self.password = self.info.saslPassword ip, port, rest_username, rest_password = server._rest_info() formatter_uri = "http://%s:%s/pools/default" self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name, self.password)
def populate_all_manifests(request): logger = logging.getLogger('dashboard') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") cbclient= CbClient("localhost", 8091, "Administrator", "password") qr = cbclient.query(bucket='default', ddoc='builds', view='manifests', limit=20000) for item in qr["rows"]: doc = item["value"] if doc["name"].find("-manifest.xml") == -1: # if doc["name"].find("-manifest.xml") == -1 and 'commits' not in doc: manifest_commits = ManifestPopulate(doc, doc["url"]).json() doc['commits'] = manifest_commits couchbase.set(doc['name'].encode('ascii','ignore'), 0, 0, json.dumps(doc).encode('ascii','ignore')) logger.info("retreived git commits for %s" % (doc['name'])) return render_to_response('../templates/dashboard/empty.html')
def populate_all_manifests(request): logger = logging.getLogger('dashboard') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") cbclient = CbClient("localhost", 8091, "Administrator", "password") qr = cbclient.query(bucket='default', ddoc='builds', view='manifests', limit=20000) for item in qr["rows"]: doc = item["value"] if doc["name"].find("-manifest.xml") == -1: # if doc["name"].find("-manifest.xml") == -1 and 'commits' not in doc: manifest_commits = ManifestPopulate(doc, doc["url"]).json() doc['commits'] = manifest_commits couchbase.set(doc['name'].encode('ascii', 'ignore'), 0, 0, json.dumps(doc).encode('ascii', 'ignore')) logger.info("retreived git commits for %s" % (doc['name'])) return render_to_response('../templates/dashboard/empty.html')
def test_two_client_incr(self): """http://www.couchbase.com/issues/browse/PYCBC-16""" key = 'test_two_client_incr' client_one = self.client client_two = CouchbaseClient(self.url, self.bucket_name, "", True) # Client one sets a numeric key client_one.set(key, 0, 0, 20) # Client two tries to increment this numeric key (i, cas) = client_two.incr(key) self.assertEqual(i, 21) # Client two should be able to keep incrementing this key (i, cas) = client_two.incr(key) self.assertEqual(i, 22) (_, cas, i) = client_two.get(key) self.assertEqual(i, 22) (i, cas) = client_two.incr(key) self.assertEqual(i, 23)
def __init__(self, name, server): self.server = server self.name = name rest = server._rest() self.password = rest.get_bucket(self.name).saslPassword ip, port, rest_username, rest_password = server._rest_info() formatter_uri = "http://%s:%s/pools/default" self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name, self.password)
class CouchbaseClientTest(Base): def setUp(self): super(CouchbaseClientTest, self).setUp() self.client = CouchbaseClient(self.url, self.bucket_name, "", True) def tearDown(self): self.client.flush() self.client.done() @nottest def setup_memcached_bucket(self): self.memcached_bucket = 'testing-memcached' self.rest_client = RestConnection({'ip': self.host, 'port': self.port, 'username': self.username, 'password': self.password}) self.rest_client.create_bucket(self.memcached_bucket, bucketType='memcached', authType='sasl', ramQuotaMB=64) self.client_for_memcached_bucket = \ CouchbaseClient(self.url, self.memcached_bucket, verbose=True) @nottest def teardown_memcached_bucket(self): self.rest_client.delete_bucket(self.memcached_bucket) @attr(cbv="1.0.0") def test_set_integer_value(self): self.client.set('int', 0, 0, 10) self.assertEqual(self.client.get('int')[2], 10, 'value should be the integer 10') self.client.incr('int') self.assertEqual(self.client.get('int')[2], 11, 'value should be the integer 11') @attr(cbv="1.0.0") def test_bucket_of_type_memcached(self): self.setup_memcached_bucket() self.assertIsInstance(self.client_for_memcached_bucket, CouchbaseClient) self.teardown_memcached_bucket()
def test_old_set_get_create_example(self): from couchbase.couchbaseclient import CouchbaseClient from couchbase.rest_client import RestConnection, RestHelper client = CouchbaseClient(self.url, self.bucket_name, "", False) client.set("key1", 0, 0, "value1") client.get("key1") server_info = { "ip": self.host, "port": self.port, "username": self.username, "password": self.password } rest = RestConnection(server_info) rest.create_bucket(bucket='newbucket', ramQuotaMB=100, authType='none', saslPassword='', replicaNumber=1, proxyPort=11215, bucketType='membase') self.assertTrue(RestHelper(rest).bucket_exists('newbucket')) rest.delete_bucket('newbucket')
def gitx(request): ''' get all commits for this project for top 20 , do view call to find out the builds ''' logger = logging.getLogger('dashboard') project = request.GET.get('project') limit = request.GET.get('limit') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") cbclient = CbClient("localhost", 8091, "Administrator", "password") a, b, value = couchbase.get(project.encode('ascii', 'ignore')) commits = json.loads(value)["tree"] counter = 0 data = list() for commit in commits: commit["builds"] = [] counter = counter + 1 filter_value = "\"%s-%s\"" % (project, commit["revision"]) params = {"startkey": filter_value, "endkey": filter_value} qr = cbclient.query(bucket='default', ddoc='builds', view='commits', limit=100, params=params) for item in qr["rows"]: logger.error(commit["builds"]) fullversion = item["value"][1].encode('ascii', 'ignore') if fullversion not in commit["builds"]: commit["builds"].append(fullversion) data.append(commit) end_index = commit["message"].find("\n") or len(commit["message"] - 1) commit["message"] = commit["message"][0:end_index] if counter == limit: break return render_to_response('../templates/dashboard/commits.html', { 'title': 'commits', 'data': data })
def test_old_set_get_create_example(self): from couchbase.couchbaseclient import CouchbaseClient from couchbase.rest_client import RestConnection, RestHelper client = CouchbaseClient(self.url, self.bucket_name, "", False) client.set("key1", 0, 0, "value1") client.get("key1") server_info = {"ip": self.host, "port": self.port, "username": self.username, "password": self.password} rest = RestConnection(server_info) rest.create_bucket( bucket="newbucket", ramQuotaMB=100, authType="none", saslPassword="", replicaNumber=1, proxyPort=11215, bucketType="membase", ) self.assertTrue(RestHelper(rest).bucket_exists("newbucket")) rest.delete_bucket("newbucket")
def setup_memcached_bucket(self): self.memcached_bucket = 'testing-memcached' self.rest_client = RestConnection({ 'ip': self.host, 'port': self.port, 'username': self.username, 'password': self.password }) self.rest_client.create_bucket(self.memcached_bucket, bucketType='memcached', authType='sasl', ramQuotaMB=64) self.client_for_memcached_bucket = \ CouchbaseClient(self.url, self.memcached_bucket, verbose=True)
def create(self, request, *args, **kwargs): couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") if request.content_type: data = request.data _id = "%s-%s-%s-%s" % (data["package"], data["arch"], data["os"], data["fullversion"]) _id = _id.encode("ascii", "ignore") couchbase.set(_id, 0, 0, json.dumps(data).encode("ascii", "ignore")) couchbase.done() return {"status": "ok"} else: return {"status": "failed", "data": request.data["os"]}
def populate_commits(request): """ for each commit create an entry in couchbase """ logger = logging.getLogger('dashboard') project = request.GET.get('project') refs = request.GET.get('refs') couchbase = CouchbaseClient("http://localhost:8091/pools/default", "default", "") refs = request.GET.get('refs') gp = GitPopulate("/space/repo/couchbase-2.0/", project, refs) commits = gp.fetch_commits() for commit in commits["tree"]: key = "%s-%s" % (commit["project"], commit["revision"]) value = json.dumps(commit).encode('ascii', 'ignore') key = key.encode('ascii', 'ignore') couchbase.set(key, 0, 0, value) key = '%s' % (project) couchbase.set(key.encode('ascii', 'ignore'), 0, 0, json.dumps(commits).encode('ascii', 'ignore')) couchbase.done() return render_to_response('../templates/dashboard/empty.html')
class CouchbaseClientTest(Base): def setUp(self): super(CouchbaseClientTest, self).setUp() self.client = CouchbaseClient(self.url, self.bucket_name, "", True) def tearDown(self): self.client.done() @nottest def setup_memcached_bucket(self): self.memcached_bucket = 'testing-memcached' self.rest_client = RestConnection({ 'ip': self.host, 'port': self.port, 'username': self.username, 'password': self.password }) self.rest_client.create_bucket(self.memcached_bucket, bucketType='memcached', authType='sasl', ramQuotaMB=64) self.client_for_memcached_bucket = \ CouchbaseClient(self.url, self.memcached_bucket, verbose=True) @nottest def teardown_memcached_bucket(self): self.rest_client.delete_bucket(self.memcached_bucket) @attr(cbv="1.0.0") def test_set_integer_value(self): self.client.set('int', 0, 0, 10) self.assertEqual( self.client.get('int')[2], 10, 'value should be the integer 10') self.client.incr('int') self.assertEqual( self.client.get('int')[2], 11, 'value should be the integer 11') self.client.delete('int') def test_two_client_incr(self): """http://www.couchbase.com/issues/browse/PYCBC-16""" key = 'test_two_client_incr' client_one = self.client client_two = CouchbaseClient(self.url, self.bucket_name, "", True) # Client one sets a numeric key client_one.set(key, 0, 0, 20) # Client two tries to increment this numeric key (i, cas) = client_two.incr(key) self.assertEqual(i, 21) # Client two should be able to keep incrementing this key (i, cas) = client_two.incr(key) self.assertEqual(i, 22) (_, cas, i) = client_two.get(key) self.assertEqual(i, 22) (i, cas) = client_two.incr(key) self.assertEqual(i, 23) def test_bucket_of_type_memcached(self): self.setup_memcached_bucket() self.assertIsInstance(self.client_for_memcached_bucket, CouchbaseClient) self.teardown_memcached_bucket()
class Bucket(object): """Handles Bucket management as well as key/value access for a specific bucket.""" def __init__(self, name, server): self.server = server self.name = name rest = server._rest() self.password = rest.get_bucket(self.name).saslPassword ip, port, rest_username, rest_password = server._rest_info() formatter_uri = "http://%s:%s/pools/default" self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name, self.password) def append(self, key, value, cas=0): return self.mc_client.append(key, value, cas) def prepend(self, key, value, cas=0): return self.mc_client.prepend(key, value, cas) def incr(self, key, amt=1, init=0, exp=0): return self.mc_client.incr(key, amt, init, exp) def decr(self, key, amt=1, init=0, exp=0): return self.mc_client.decr(key, amt, init, exp) def set(self, key, expiration, flags, value): return self.mc_client.set(key, expiration, flags, value) def add(self, key, exp, flags, val): return self.mc_client.add(key, exp, flags, val) def replace(self, key, exp, flags, val): return self.mc_client.replace(key, exp, flags, val) def get(self, key): return self.mc_client.get(key) def getl(self, key, exp=15): return self.mc_client.getl(key, exp) def cas(self, key, exp, flags, oldVal, val): return self.mc_client.cas(key, exp, flags, oldVal, val) def touch(self, key, exp): return self.mc_client.touch(key, exp) def gat(self, key, exp): return self.mc_client.gat(key, exp) def stats(self, sub=''): return self.mc_client.stats(sub) def delete(self, key, cas=0): if key.startswith('_design/'): # this is a design doc, we need to handle it differently view = key.split('/')[1] rest = self.server._rest() rest.delete_view(self.name, view) else: return self.mc_client.delete(key, cas) def save(self, document): value = deepcopy(document) if '_id' in value: key = value['_id'] del value['_id'] else: key = str(uuid.uuid4()) if '$flags' in value: flags = value['$flags'] del value['$flags'] else: flags = 0 if '$expiration' in value: expiration = value['$expiration'] del value['$expiration'] else: expiration = 0 if key.startswith('_design/'): # this is a design doc, we need to handle it differently view = key.split('/')[1] rest = self.server._rest() rest.create_design_doc(self.name, view, json.dumps(value)) else: if '_rev' in value: # couchbase works in clobber mode so for "set" _rev is useless del value['_rev'] self.set(key, expiration, flags, json.dumps(value)) return key def __setitem__(self, key, value): if isinstance(value, dict): self.set(key, value['expiration'], value['flags'], value['value']) else: self.set(key, 0, 0, value) def __getitem__(self, key): return self.get(key) def view(self, view, **options): params = deepcopy(options) limit = None if 'limit' in params: limit = params['limit'] del params['limit'] if view.startswith("_design/"): view_s = view.split('/') view_doc = view_s[1] view_map = view_s[3] else: view_doc = view view_map = None rest = self.server._rest() results = rest.view_results(self.name, view_doc, view_map, params, limit) if 'rows' in results: return results['rows'] else: return None
class Bucket(object): """Handles Bucket management as well as key/value access for a specific bucket.""" def __init__(self, name, server): self.server = server self.name = name rest = server._rest() self.info = rest.get_bucket(self.name) self.password = self.info.saslPassword ip, port, rest_username, rest_password = server._rest_info() formatter_uri = "http://%s:%s/pools/default" self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name, self.password) def __del__(self): self.mc_client.done() def append(self, key, value, cas=0): return self.mc_client.append(key, value, cas) def prepend(self, key, value, cas=0): return self.mc_client.prepend(key, value, cas) def incr(self, key, amt=1, init=0, exp=0): return self.mc_client.incr(key, amt, init, exp) def decr(self, key, amt=1, init=0, exp=0): return self.mc_client.decr(key, amt, init, exp) def set(self, key, expiration, flags, value): if isinstance(value, dict): value = json.dumps(value) return self.mc_client.set(key, expiration, flags, value) def add(self, key, exp, flags, val): return self.mc_client.add(key, exp, flags, val) def replace(self, key, exp, flags, val): return self.mc_client.replace(key, exp, flags, val) def get(self, key): return self.mc_client.get(key) def getl(self, key, exp=15): return self.mc_client.getl(key, exp) def cas(self, key, exp, flags, oldVal, val): return self.mc_client.cas(key, exp, flags, oldVal, val) def touch(self, key, exp): return self.mc_client.touch(key, exp) def gat(self, key, exp): return self.mc_client.gat(key, exp) def stats(self, sub=''): return self.mc_client.stats(sub) def delete(self, key, cas=0): if key.startswith('_design/'): # this is a design doc, we need to handle it differently view = key.split('/')[1] rest = self.server._rest() rest.delete_view(self.name, view) else: return self.mc_client.delete(key, cas) def save(self, document): warnings.warn("save is deprecated; use set instead", DeprecationWarning) value = deepcopy(document) if '_id' in value: key = value['_id'] del value['_id'] else: key = str(uuid.uuid4()) if '$flags' in value: flags = value['$flags'] del value['$flags'] else: flags = 0 if '$expiration' in value: expiration = value['$expiration'] del value['$expiration'] else: expiration = 0 if key.startswith('_design/'): self[key] = value else: if '_rev' in value: # couchbase works in clobber mode so for "set" _rev is useless del value['_rev'] self.set(key, expiration, flags, json.dumps(value)) return key def __setitem__(self, key, value): if isinstance(value, dict): if 'expiration' in value or 'flags' in value: assert 'value' in value if isinstance(value['value'], dict): v = json.dumps(value['value']) else: v = value['value'] self.set(key, value.get('expiration', 0), value.get('flags', 0), v) elif key.startswith('_design/'): rest = self.server._rest() rest.create_design_doc(self.name, key[8:], json.dumps(value)) else: self.set(key, 0, 0, json.dumps(value)) else: self.set(key, 0, 0, value) def __getitem__(self, key): if key.startswith("_design/"): rest = self.server._rest() doc = rest.get_design_doc(self.name, key[8:]) return DesignDoc(key[8:], doc, self) else: return self.get(key) def view(self, view, **options): params = deepcopy(options) limit = None if 'limit' in params: limit = params['limit'] del params['limit'] if view.startswith("_design/"): view_s = view.split('/') view_doc = view_s[1] view_map = view_s[3] else: view_doc = view view_map = None rest = self.server._rest() results = rest.view_results(self.name, view_doc, view_map, params, limit) if 'rows' in results: return results['rows'] else: return None def design_docs(self): """List all design documents and return DesignDoc objects for each""" (ip, port, _, _) = self.server._rest_info() api = ''.join(['http://{0}:{1}'.format(ip, port), self.info.ddocs['uri']]) r = requests.get(api, auth=(self.server.rest_username, self.server.rest_password)) ddocs = [] for ddoc in r.json().get('rows'): ddocs.append(DesignDoc(ddoc['doc']['meta']['id'], ddoc['doc']['json'], bucket=self)) return ddocs def flush(self): """RESTful Bucket flushing - will destory all the data in a bucket.""" ip, port, rest_username, rest_password = self.server._rest_info() api = ''.join(["http://{0}:{1}".format(ip, port), self.info.controllers['flush']]) response = requests.post(api, auth=(rest_username, rest_password)) if response.status_code is 503: raise Exception("Only buckets of type 'memcached' support flush.") elif response.status_code is 404: raise BucketUnavailableException elif response.status_code is 200: return True
data["version"] = "2.0.0" if re.search(r'\d\.\d\.\d-\d*-\w\w\w', name): data["fullversion"] = re.search(r'\d\.\d\.\d-\d*-\w\w\w', name).group() data["url"] = "http://builds.hq.northscale.net/latestbuilds/%s" % (data["name"]) if "arch" not in data: data["arch"] = "unknown" kv_data[data["name"]] = data result = {} for item in kv_data: if "package" not in kv_data[item] or "fullversion" not in kv_data[item]: continue result[item] = kv_data[item] with open('/tmp/jsonified.json', 'wb') as fp: json.dump(result, fp) c = CouchbaseClient("http://localhost:8091/pools/default", "default", "") #id will be product-architechture-package-fullversion print len(result) for item in result: _id = "%s-%s-%s-%s" % (result[item]["package"], result[item]["arch"], result[item]["os"], result[item]["fullversion"]) c.set(_id.encode("ascii", "ignore"), 0, 0, json.dumps(result[item]).encode("ascii", "ignore")) all_names = {"list":[]} for item in result: all_names["list"].append(item.encode("ascii", "ignore")) c.set("all-builds", 0, 0, json.dumps(all_names).encode("ascii", "ignore"))
def setUp(self): super(CouchbaseClientTest, self).setUp() self.client = CouchbaseClient(self.url, self.bucket_name, "", True)
class Bucket(object): """Handles Bucket management as well as key/value access for a specific bucket.""" def __init__(self, name, server): self.server = server self.name = name rest = server._rest() self.info = rest.get_bucket(self.name) self.password = self.info.saslPassword ip, port, rest_username, rest_password = server._rest_info() formatter_uri = "http://%s:%s/pools/default" self.mc_client = CouchbaseClient(formatter_uri % (ip, port), self.name, self.password) def __del__(self): self.mc_client.done() def append(self, key, value, cas=0): return self.mc_client.append(key, value, cas) def prepend(self, key, value, cas=0): return self.mc_client.prepend(key, value, cas) def incr(self, key, amt=1, init=0, exp=0): return self.mc_client.incr(key, amt, init, exp) def decr(self, key, amt=1, init=0, exp=0): return self.mc_client.decr(key, amt, init, exp) def set(self, key, expiration, flags, value): if isinstance(value, dict): value = json.dumps(value) return self.mc_client.set(key, expiration, flags, value) def add(self, key, exp, flags, val): return self.mc_client.add(key, exp, flags, val) def replace(self, key, exp, flags, val): return self.mc_client.replace(key, exp, flags, val) def get(self, key): return self.mc_client.get(key) def getl(self, key, exp=15): return self.mc_client.getl(key, exp) def cas(self, key, exp, flags, oldVal, val): return self.mc_client.cas(key, exp, flags, oldVal, val) def touch(self, key, exp): return self.mc_client.touch(key, exp) def gat(self, key, exp): return self.mc_client.gat(key, exp) def stats(self, sub=''): return self.mc_client.stats(sub) def delete(self, key, cas=0): if key.startswith('_design/'): # this is a design doc, we need to handle it differently view = key.split('/')[1] rest = self.server._rest() rest.delete_view(self.name, view) else: return self.mc_client.delete(key, cas) def save(self, document): warnings.warn("save is deprecated; use set instead", DeprecationWarning) value = deepcopy(document) if '_id' in value: key = value['_id'] del value['_id'] else: key = str(uuid.uuid4()) if '$flags' in value: flags = value['$flags'] del value['$flags'] else: flags = 0 if '$expiration' in value: expiration = value['$expiration'] del value['$expiration'] else: expiration = 0 if key.startswith('_design/'): self[key] = value else: if '_rev' in value: # couchbase works in clobber mode so for "set" _rev is useless del value['_rev'] self.set(key, expiration, flags, json.dumps(value)) return key def __setitem__(self, key, value): if isinstance(value, dict): if 'expiration' in value or 'flags' in value: assert 'value' in value if isinstance(value['value'], dict): v = json.dumps(value['value']) else: v = value['value'] self.set(key, value.get('expiration', 0), value.get('flags', 0), v) elif key.startswith('_design/'): rest = self.server._rest() rest.create_design_doc(self.name, key[8:], json.dumps(value)) else: self.set(key, 0, 0, json.dumps(value)) else: self.set(key, 0, 0, value) def __getitem__(self, key): if key.startswith("_design/"): rest = self.server._rest() doc = rest.get_design_doc(self.name, key[8:]) return DesignDoc(key[8:], doc, self) else: return self.get(key) def view(self, view, **options): params = deepcopy(options) limit = None if 'limit' in params: limit = params['limit'] del params['limit'] if view.startswith("_design/"): view_s = view.split('/') view_doc = view_s[1] view_map = view_s[3] else: view_doc = view view_map = None rest = self.server._rest() results = rest.view_results(self.name, view_doc, view_map, params, limit) if 'rows' in results: return results['rows'] else: return None def design_docs(self): """List all design documents and return DesignDoc objects for each""" (ip, port, _, _) = self.server._rest_info() api = ''.join( ['http://{0}:{1}'.format(ip, port), self.info.ddocs['uri']]) r = requests.get(api, auth=(self.server.rest_username, self.server.rest_password)) ddocs = [] for ddoc in r.json().get('rows'): ddocs.append( DesignDoc(ddoc['doc']['meta']['id'], ddoc['doc']['json'], bucket=self)) return ddocs def flush(self): """RESTful Bucket flushing - will destory all the data in a bucket.""" ip, port, rest_username, rest_password = self.server._rest_info() api = ''.join([ "http://{0}:{1}".format(ip, port), self.info.controllers['flush'] ]) response = requests.post(api, auth=(rest_username, rest_password)) if response.status_code is 503: raise Exception("Only buckets of type 'memcached' support flush.") elif response.status_code is 404: raise BucketUnavailableException elif response.status_code is 200: return True
def __init__(self): from couchbase.couchbaseclient import CouchbaseClient self.client = \ CouchbaseClient('http://{0}:8091/pools/default'.format(HOST), 'default')
if re.search(r'\d\.\d\.\d-\d*-\w\w\w', name): data["fullversion"] = re.search(r'\d\.\d\.\d-\d*-\w\w\w', name).group() data["url"] = "http://builds.hq.northscale.net/latestbuilds/%s" % ( data["name"]) if "arch" not in data: data["arch"] = "unknown" kv_data[data["name"]] = data result = {} for item in kv_data: if "package" not in kv_data[item] or "fullversion" not in kv_data[item]: continue result[item] = kv_data[item] with open('/tmp/jsonified.json', 'wb') as fp: json.dump(result, fp) c = CouchbaseClient("http://localhost:8091/pools/default", "default", "") #id will be product-architechture-package-fullversion print len(result) for item in result: _id = "%s-%s-%s-%s" % (result[item]["package"], result[item]["arch"], result[item]["os"], result[item]["fullversion"]) c.set(_id.encode("ascii", "ignore"), 0, 0, json.dumps(result[item]).encode("ascii", "ignore")) all_names = {"list": []} for item in result: all_names["list"].append(item.encode("ascii", "ignore")) c.set("all-builds", 0, 0, json.dumps(all_names).encode("ascii", "ignore"))