def main(): usage = \ """ %prog [options] prefix """ description = \ """Use this program to clear databases in couch that match a given prefix """ parser = OptionParser(usage=usage, description=description) parser.add_option("-p", "--port", dest="couch_port", default=5984, help="specify a port for couch", action="store", type=int, metavar="PORT") parser.add_option("-n", "--host", dest="couch_host", default='localhost', help="The host name or ip address of the couch server", action="store", type=str, metavar="HOST") parser.add_option("-u", "--user_name", dest="couch_uname", default=None, help="User name for the couch server", action="store", type=str, metavar="UNAME") parser.add_option("-s", "--password", dest="couch_pword", default=None, help="Password for the couch server", action="store", type=str, metavar="PWORD") #parser.add_option("-s", "--sysname", dest="sysname", default=None, help="The sysname prefix to clear in couch", action="store", type=str, metavar="SYSNAME") (options, args) = parser.parse_args() # Hack to set the user name and password if len(args) ==0: print '$ Error: no prefix argument specified' parser.print_help() sys.exit() if len(args) != 1: print '$ Error: You can not specify multiple prefixes. Received args: %s' % str(args) parser.print_help() sys.exit() prefix = args[0] if prefix is '': print '$ Error: You can not give the empty string as a prefix!' parser.print_help() sys.exit() if options.couch_uname is not None: CFG.server.couchdb.username = options.couch_uname if options.couch_pword is not None: CFG.server.couchdb.password = options.couch_pword db_server = CouchDB_DataStore(host=options.couch_host, port=options.couch_port) print "$ Connected to couch database @: host %s, port %d" % (options.couch_host, options.couch_port) db_list = db_server.list_datastores() for db_name in db_list: if db_name.startswith(prefix): db_server.delete_datastore(db_name) print '$ Cleared couch db named: %s' % db_name else: print '$ Ignoring couch db named: %s' % db_name
def _force_clean(self, recreate=False): from pyon.core.bootstrap import get_sys_name datastore = CouchDB_DataStore() dbs = datastore.list_datastores() things_to_clean = filter(lambda x: x.startswith('%s_' % get_sys_name()), dbs) try: for thing in things_to_clean: datastore.delete_datastore(datastore_name=thing) if recreate: datastore.create_datastore(datastore_name=thing) finally: datastore.close()
def _force_clean(self, recreate=False): from pyon.core.bootstrap import get_sys_name datastore = CouchDB_DataStore() dbs = datastore.list_datastores() things_to_clean = filter( lambda x: x.startswith('%s_' % get_sys_name()), dbs) try: for thing in things_to_clean: datastore.delete_datastore(datastore_name=thing) if recreate: datastore.create_datastore(datastore_name=thing) finally: datastore.close()
def test_datastore_basic(self): data_store = CouchDB_DataStore(datastore_name='ion_test_ds', profile=DataStore.DS_PROFILE.RESOURCES) self.data_store = data_store self.resources = {} # Just in case previous run failed without cleaning up, # delete data store data_store.delete_datastore() # Create should succeed and not throw error data_store.create_datastore() # Create should throw exception the second time with self.assertRaises(BadRequest): data_store.create_datastore() # Call ops with wrong object type and make sure exception is thrown with self.assertRaises(BadRequest): data_store.create({"foo": "bar"}) with self.assertRaises(BadRequest): data_store.create_mult([{"foo": "bar"}]) with self.assertRaises(BadRequest): data_store.read({"foo": "bar"}) with self.assertRaises(BadRequest): data_store.read_mult([{"foo": "bar"}]) with self.assertRaises(BadRequest): data_store.update({"foo": "bar"}) with self.assertRaises(BadRequest): data_store.delete({"foo": "bar"}) # Should see new data self.assertIn('ion_test_ds', data_store.list_datastores()) # Something should be returned self.assertTrue(data_store.info_datastore() is not None) res = data_store.list_objects() numcoredocs = len(res) # Construct user role objects admin_role = { "name":"Admin", "description":"Super user" } admin_role_obj = IonObject('UserRole', admin_role) admin_role_tuple = data_store.create(admin_role_obj) self.assertTrue(len(admin_role_tuple) == 2) admin_role_ooi_id = admin_role_tuple[0] data_provider_role = { "name":"Data Provider", "description":"User allowed to ingest data sets" } data_provider_role_obj = IonObject('UserRole', data_provider_role) data_provider_role_tuple = data_store.create(data_provider_role_obj) self.assertTrue(len(data_provider_role_tuple) == 2) data_provider_role_ooi_id = data_provider_role_tuple[0] marine_operator_role = { "name":"Marine Operator", "description":"User allowed to administer instruments" } marine_operator_role_obj = IonObject('UserRole', marine_operator_role) marine_operator_role_tuple = data_store.create(marine_operator_role_obj) self.assertTrue(len(marine_operator_role_tuple) == 2) marine_operator_role_ooi_id = marine_operator_role_tuple[0] role_objs = data_store.read_mult([admin_role_ooi_id, data_provider_role_ooi_id, marine_operator_role_ooi_id]) self.assertTrue(len(role_objs) == 3) self.assertTrue(role_objs[0]._id == admin_role_ooi_id) self.assertTrue(role_objs[1]._id == data_provider_role_ooi_id) self.assertTrue(role_objs[2]._id == marine_operator_role_ooi_id) # Construct three user info objects and assign them roles hvl_contact_info = { "individual_names_given": "Heitor Villa-Lobos", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Legendary Brazilian composer"} ] } hvl_contact_info_obj = IonObject('ContactInformation', hvl_contact_info) hvl_user_info = { "name": "Heitor Villa-Lobos", "contact": hvl_contact_info_obj } hvl_user_info_obj = IonObject('UserInfo', hvl_user_info) hvl_user_info_tuple = data_store.create(hvl_user_info_obj) self.assertTrue(len(hvl_user_info_tuple) == 2) heitor_villa_lobos_ooi_id = hvl_user_info_tuple[0] ats_contact_info = { "individual_names_given": "Andres Torres Segovia", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Legendary Concert Guitarist"} ] } ats_contact_info_obj = IonObject('ContactInformation', ats_contact_info) ats_user_info = { "name": "Andres Torres Segovia", "contact": ats_contact_info_obj } ats_user_info_obj = IonObject('UserInfo', ats_user_info) ats_user_info_tuple = data_store.create(ats_user_info_obj) self.assertTrue(len(ats_user_info_tuple) == 2) pok_contact_info = { "individual_names_given": "Per-Olov Kindgren", "email": "*****@*****.**", "variables": [ {"name": "Claim To Fame", "value": "Composer and YouTube star"} ] } pok_contact_info_obj = IonObject('ContactInformation', pok_contact_info) pok_user_info = { "name": "Per-Olov Kindgren", "contact": pok_contact_info_obj } pok_user_info_obj = IonObject('UserInfo', pok_user_info) pok_user_info_tuple = data_store.create(pok_user_info_obj) self.assertTrue(len(pok_user_info_tuple) == 2) # List all objects in data store and confirm there are six docs res = data_store.list_objects() # There are indices. Therefore can't could all docs self.assertTrue(len(res) == 6 + numcoredocs) # Create an Ion object with default values set (if any) data_set = IonObject('Dataset') self.assertTrue(isinstance(data_set, interface.objects.Dataset)) # Assign values to object fields data_set.description = "Real-time water data for Choptank River near Greensboro, MD" # Write Dataset object" write_tuple_1 = data_store.create(data_set) self.assertTrue(len(write_tuple_1) == 2) # Save off the object UUID data_set_uuid = write_tuple_1[0] # Read back the HEAD version of the object and validate fields data_set_read_obj = data_store.read(data_set_uuid) self.assertTrue(data_set_read_obj._id == data_set_uuid) self.assertTrue(isinstance(data_set_read_obj, interface.objects.Dataset)) self.assertTrue(data_set_read_obj.description == "Real-time water data for Choptank River near Greensboro, MD") self.assertTrue('type_' in data_set_read_obj) # Update Dataset's Description field and write data_set_read_obj.description = "Updated Description" write_tuple_2 = data_store.update(data_set_read_obj) self.assertTrue(len(write_tuple_2) == 2) # Retrieve the updated Dataset data_set_read_obj_2 = data_store.read(data_set_uuid) self.assertTrue(data_set_read_obj_2._id == data_set_uuid) self.assertTrue(data_set_read_obj_2.description == "Updated Description") # List all the revisions of Dataset in data store, should be two res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 2) # Do another update to the object data_set_read_obj_2.description = "USGS instantaneous value data for station 01491000" write_tuple_3 = data_store.update(data_set_read_obj_2) # List revisions of Dataset in data store, should now be three res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 3) # Retrieve original version of Dataset obj1 = data_store.read(data_set_uuid, rev_id=write_tuple_1[1]) self.assertTrue(obj1._id == data_set_uuid) self.assertTrue(obj1.description == "Real-time water data for Choptank River near Greensboro, MD") # Retrieve second version of Dataset obj2 = data_store.read(data_set_uuid, rev_id=write_tuple_2[1]) self.assertTrue(obj2._id == data_set_uuid) self.assertTrue(obj2.description == "Updated Description") # Retrieve third version of Dataset obj3 = data_store.read(data_set_uuid, rev_id=write_tuple_3[1]) self.assertTrue(obj3._id == data_set_uuid) self.assertTrue(obj3.description == "USGS instantaneous value data for station 01491000") # Retrieve HEAD version of Dataset head = data_store.read(data_set_uuid) self.assertTrue(head._id == data_set_uuid) self.assertTrue(head.description == "USGS instantaneous value data for station 01491000") # Delete Dataset by object id data_store.delete(head) # Try to re-delete Dataset by object id. Should throw exception. with self.assertRaises(NotFound): data_store.delete(head._id) # List all objects in data store, should be back to six res = data_store.list_objects() self.assertTrue(len(res) == 6 + numcoredocs) # List revisions of now deleted Dataset, should be empty list res = data_store.list_object_revisions(data_set_uuid) self.assertTrue(len(res) == 0) o1 = IonObject("Dataset", name="One more") o2 = IonObject("Dataset", name="Another one") res = data_store.create_mult((o1, o2)) self.assertTrue(all([success for success, oid, rev in res])) res = data_store.list_objects() self.assertTrue(len(res) == 8 + numcoredocs) # Delete data store to clean up data_store.delete_datastore() # Assert data store is now gone self.assertNotIn('ion_test_ds', data_store.list_datastores())