def _getHash(self, usrFacingUrlPrefix): scan_range = Range(srow=usrFacingUrlPrefix, scf=self.__cf, scq="hash", erow=usrFacingUrlPrefix, ecf=self.__cf, ecq="hash") for entry in self.__connection.scan(self.__table, scanrange=scan_range): return str(entry.val) else: return None
def get_single_entry(conn, table, row=None, cf=None, cq=None): """ Get the single entry with the given key fields (row, column family, and column qualifier) from an Accumulo database. Returns: None if no entries were found The found entry if exactly one was found Raises an assertion error if more than one entry was found """ if cf is None: assert cq is None cols = None elif cq is None: cols = [[cf]] else: cols = [[cf, cq]] candidates = conn.scan(table, Range(srow=row, erow=row), cols=cols) try: first = next(candidates) except StopIteration: # No candidates; return None return None try: more = next(candidates) assert False # only supposed to have one result except StopIteration: return first
def _getNofChunks(self, usrFacingUrlPrefix): ''' Get the number of chunks the static contents is stored ''' scan_range = Range(srow=usrFacingUrlPrefix, scf=self.__cf, scq="nofchunks", erow=usrFacingUrlPrefix, ecf=self.__cf, ecq="nofchunks") for entry in self.__connection.scan(self.__table, scanrange=scan_range): return int(entry.val) return 0
def attributes_by_user(self, userid): """ Returns a list of the attributes the given user has. Arguments: userid (string) - the ID of the user whose attributes to retrieve Returns: [string] - a (potentially empty) list of the attributes that the given user has """ # Scan the user-to-attribute table for the row for this user raw_attrs = self.conn.scan(self.user_attr_table, Range(srow=userid, erow=userid)) # Grab the column family (where the attribute is stored) for each entry return [entry.cf for entry in raw_attrs]
def from_elem(self, elem): """ Check if an element is in the database. If so, return an embedded node pointing to that element's leaf node in the skiplist. If not, return None. """ key = sha256(elem.serialize()).digest() candidates = self.conn.scan(self.table, Range(srow=key, erow=key)) try: first = next(candidates) except StopIteration: # It's not there, so return None return None # Otherwise, this row is there, so return the node with the right name return EmbeddedNode(self, key)
def entry_exists(conn, table, row, cf=None, cq=None): """ Check to see if at least one entry with the given information exists in the given Accumulo table. Takes at least a row, and possibly a column family & qualifier as well. Arguments: conn : Accumulo - a connection to the Accumulo instance to check table : string - the name of the table to check row : string - the name of the row to look for within the given table cf : optional string - the column family to look for, if desired cq : optional string - the column qualifier to look for, if desired Returns: bool - whether there is at least one entry in the given connection with the given fields Assumptions: - The given table exists on the connection - If cf is not specified/None, then neither is cq """ if cf is None: assert cq is None cols = None elif cq is None: cols = [[cf]] else: cols = [[cf, cq]] candidates = conn.scan(table, Range(srow=row, erow=row), cols=cols) try: first = next(candidates) except StopIteration: # Nothing found return False else: # Something found return True
def _split_entry(self, entry): tup = (entry.row, entry.cf, entry.cq, entry.cv, None, entry.val) cell_string = str(tup) lookup_string = str(tup[:-1]) sig_entries = [ x for x in self.conn.scan(self.table, scanrange=Range(srow=lookup_string, erow=lookup_string)) ] assert len(sig_entries) == 1 sig_entry = sig_entries[0] metadata, sig = sig_entry.val.split(',') return (SignedEntry(cell_string=cell_string, metadata=metadata, sig=sig), entry ) # no metadata in the entry, so just return it
def users_by_attribute(self, attr): """ Return the list of all users who are currently authorized to read data with the given attribute. Arguments: attr : string - the attribute to query Returns: users : [string] - a (potentially empty) list of usernames (as strings) that are all authorized to have the given attribute `attr` """ # Scan the attribute-to-user table for the row for this attribute raw_users = self.conn.scan(self.attr_user_table, Range(srow=attr, erow=attr)) # Grab the column family (where the user is stored) for each entry return [entry.cf for entry in raw_users]
def get_metadatas(self, user, attr): """ Get all metadatas that a given user has for a particular attribute. Arguments: self - the KeyStore object to delete elements from userid : string - the ID of the user whose metadata is being fetched attr : string - the attribute whose metadata is being fetched Returns: metadatas : string set - a set of metadata strings """ # Scan the keywrap metadata table for the metadatas # Row: user # Col. Fam: attribute raw_metas = self.conn.scan(self.meta_table, Range(srow=user, erow=user), cols=[[attr]]) return set([entry.cq for entry in raw_metas])
def _run_search(self, config, row, cols, correct_cells): ''' Tests the encrypting search functionality ''' #create range & mutation to search for mut1 = Mutation('arow') mut1.put(cf='cf1', cq='cq1', cv='', ts=1, val='val1') mut1.put(cf='cf2', cq='cq2', cv='', ts=2, val='val2') mut1.put(cf='cf1', cq='cq1', cv='', ts=3, val='val3') mut1.put(cf='cf2', cq='cq3', cv='', ts=4, val='val4') mut1.put(cf='cf3', cq='cq4', cv='', ts=5, val='val5') mut2 = Mutation('brow') mut2.put(cf='cf1', cq='cq1', cv='', ts=6, val='val1') mut2.put(cf='cf2', cq='cq2', cv='', ts=7, val='val2') ae = AccumuloEncrypt(StringIO(config), self.pki) enc_muts1 = ae.encrypt(mut1) enc_muts2 = ae.encrypt(mut2) enc_row, enc_cols = ae.encrypt_search(row, cols) #write mutation along fake connection conn = FakeConnection() conn.create_table('enc_test') for mut in enc_muts1 + enc_muts2: conn.write('enc_test', mut) #retrieve encrypted mutation with search dec_cells = [] for c in conn.scan('enc_test', scanrange=Range(srow=enc_row, erow=enc_row, sinclude=True, einclude=True), cols=enc_cols): dec_cells.append(ae.decrypt(c)) self.assertEqual(sorted(dec_cells), sorted(correct_cells))
table = "pythontest" conn = Accumulo(host=settings.HOST, port=settings.PORT, user=settings.USER, password=settings.PASSWORD) if conn.table_exists(table): conn.delete_table(table) conn.create_table(table) wr = conn.create_batch_writer(table) print "Ingesting some data ..." for num in range(1, 100): label = '%03d'%num mut = Mutation('r_%s'%label) mut.put(cf='cf_%s'%label, cq='cq1', val='value_%s'%label) mut.put(cf='cf_%s'%label, cq='cq2', val='value_%s'%label) wr.add_mutation(mut) wr.close() print "Rows 001 through 003 ..." for entry in conn.scan(table, scanrange=Range(srow='r_001', erow='r_003'), cols=[]): print entry print "Rows 001 and 011 ..." for entry in conn.batch_scan(table, scanranges=[Range(srow='r_001', erow='r_001'), Range(srow='r_011', erow='r_011')]): print entry conn.close()
def batch_retrieve(self, userid, metadata, attr=None): """ Fetch all of a user's keys at once. Optionally, fetch only their keys either for a specified attribute or with no attribute at all. Arguments: self - the KeyStore object being read from userid : string - the ID of the user whose keys to fetch metadata : string - the metadata of the keys to search for attr : optional string - the attribute to search for. Default value: None. If this argument is None, this method should return all of the given user's keys. If this argument is the empty string, it should return that user's non-attribute keys. If this argument is a non-empty string, it should return all of that user's keys for that attribute, including all versions and metadata options. Returns: [KeyInfo] - a non-empty list of KeyInfo objects (that is, (attr, vers, metadata, keywrap, keylen) tuples). If the attr argument was None, the attr field of each tuple will be the attribute corresponding to the returned version, metadata, and keywrap; otherwise, the attr field of each tuple will be equal to the attr argument. Raises: PKILookupError - if there is no information to be returned """ tabname = metadata if not self.conn.table_exists(tabname): raise PKILookupError('Error: no such table %s' %tabname) if attr is None: # Get everything! scan_range = Range(srow=userid, erow=userid) else: # Get only things from the corresponding row scan_range = Range(srow=userid, erow=userid, scf=attr, ecf=attr) ret = [] for c in self.conn.scan(tabname, scan_range): try: vers = int(c.cq) except ValueError: raise PKILookupException('Retrieved version must be int') keywrap, raw_keylen = c.val.rsplit(',', 1) try: keylen = int(raw_keylen) except ValueError: raise PKILookupError('Error: found non-integer key length') ret.append(KeyInfo(metadata=metadata, attr=c.cf, vers=vers, keywrap=keywrap, keylen=keylen)) if not ret: # If we found no elements, that's an error raise PKILookupError( 'Error: no results found for batch key retrieval') else: return ret
from pyaccumulo.proxy.ttypes import IteratorSetting, IteratorScope from examples.util import hashcode import hashlib, re import settings import sys conn = Accumulo(host=settings.HOST, port=settings.PORT, user=settings.USER, password=settings.PASSWORD) table = sys.argv[1] if not conn.table_exists(table): print "Table '%s' does not exist."%table sys.exit(1) search_terms = [term.lower() for term in sys.argv[2:] if len(term) > 3] if len(search_terms) < 2: print "More than one term of length > 3 is required for this example" sys.exit(1) uuids = [] for e in conn.batch_scan(table, scanranges=[Range(srow="s", erow="t")], iterators=[IntersectingIterator(priority=21, terms=search_terms)]): uuids.append(e.cq) if len(uuids) > 0: for doc in conn.batch_scan(table, scanranges=[Range(srow=uuid, erow=uuid) for uuid in uuids]): print doc.val else: print "No results found" conn.close()