def test_rr_create_with_id(self):
res_obj1 = IonObject(RT.ActorIdentity)
newid = uuid.uuid4().hex
rid1, _ = self.rr.create(res_obj1, object_id=newid)
self.assertEqual(rid1, newid)
res_list = [
IonObject(RT.TestInstrument, name="ID1"),
IonObject(RT.TestInstrument, name="ID2"),
IonObject(RT.TestInstrument, name="ID3"),
]
rid_list = self.rr.create_mult(res_list)
self.assertEquals(len(rid_list), 3)
owned_list, _ = self.rr.find_subjects(subject_type=RT.TestInstrument, predicate=PRED.hasOwner, object=rid1, id_only=True)
self.assertEquals(len(owned_list), 0)
self.rr.rr_store.delete_mult([rid for (rid, rrv) in rid_list])
rid_list = self.rr.create_mult(res_list, actor_id=rid1)
self.assertEquals(len(rid_list), 3)
owned_list, _ = self.rr.find_subjects(subject_type=RT.TestInstrument, predicate=PRED.hasOwner, object=rid1, id_only=True)
self.assertEquals(len(owned_list), 3)
self.rr.rr_store.delete_mult([rid for (rid, rrv) in rid_list])
self.rr.delete(rid1)
def test_get_resource_extension(self):
#Testing multiple instrument owners
subject1 = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Roger Unwin A254"
actor_identity_obj1 = IonObject("ActorIdentity", {"name": subject1})
user_id1,_ = self.rr.create(actor_identity_obj1)
user_info_obj1 = IonObject("UserInfo", {"name": "Foo"})
user_info_id1,_ = self.rr.create(user_info_obj1)
self.rr.create_association(user_id1, PRED.hasInfo, user_info_id1)
subject2 = "/DC=org/DC=cilogon/C=US/O=ProtectNetwork/CN=Bob Cumbers A256"
actor_identity_obj2 = IonObject("ActorIdentity", {"name": subject2})
user_id2,_ = self.rr.create(actor_identity_obj2)
user_info_obj2 = IonObject("UserInfo", {"name": "Foo2"})
user_info_id2,_ = self.rr.create(user_info_obj2)
self.rr.create_association(user_id2, PRED.hasInfo, user_info_id2)
test_obj = IonObject('InformationResource', {"name": "TestResource"})
test_obj_id,_ = self.rr.create(test_obj)
self.rr.create_association(test_obj_id, PRED.hasOwner, user_id1)
self.rr.create_association(test_obj_id, PRED.hasOwner, user_id2)
extended_resource = self.rr.get_resource_extension(test_obj_id, 'ExtendedInformationResource')
self.assertEqual(test_obj_id,extended_resource._id)
self.assertEqual(len(extended_resource.owners),2)
extended_resource_list = self.rr.get_resource_extension(str([user_info_id1,user_info_id2]), 'ExtendedInformationResource')
self.assertEqual(len(extended_resource_list), 2)
def test_rr_read_assoc(self):
res_obj1 = IonObject(RT.Org)
rid1, _ = self.rr.create(res_obj1)
res_obj2 = IonObject(RT.InstrumentDevice)
rid2, _ = self.rr.create(res_obj2)
with self.assertRaises(NotFound) as ex:
read_obj2 = self.rr.read_object(rid1, PRED.hasResource)
aid1, _ = self.rr.create_association(rid1, PRED.hasResource, rid2)
read_obj2 = self.rr.read_object(rid1, PRED.hasResource)
self.assertEquals(read_obj2._id, rid2)
read_obj2 = self.rr.read_object(rid1, PRED.hasResource, id_only=True)
self.assertEquals(read_obj2, rid2)
read_obj2 = self.rr.read_object(assoc=aid1)
self.assertEquals(read_obj2._id, rid2)
read_obj1 = self.rr.read_subject(None, PRED.hasResource, rid2)
self.assertEquals(read_obj1._id, rid1)
read_obj1 = self.rr.read_subject(None,
PRED.hasResource,
rid2,
id_only=True)
self.assertEquals(read_obj1, rid1)
read_obj1 = self.rr.read_subject(assoc=aid1)
self.assertEquals(read_obj1._id, rid1)
res_obj3 = IonObject(RT.InstrumentDevice)
rid3, _ = self.rr.create(res_obj3)
res_obj4 = IonObject(RT.Org)
rid4, _ = self.rr.create(res_obj4)
aid2, _ = self.rr.create_association(rid1, PRED.hasResource, rid3)
aid3, _ = self.rr.create_association(rid4, PRED.hasResource, rid3)
with self.assertRaises(Inconsistent) as ex:
read_obj2 = self.rr.read_object(rid1, PRED.hasResource)
with self.assertRaises(Inconsistent) as ex:
read_obj1 = self.rr.read_subject(None, PRED.hasResource, rid3)
res_obj5 = IonObject(RT.PlatformDevice)
rid5, _ = self.rr.create(res_obj5)
aid4, _ = self.rr.create_association(rid1, PRED.hasResource, rid5)
read_obj5 = self.rr.read_object(rid1, PRED.hasResource,
RT.PlatformDevice)
def trigger_garbage_collection(self):
"""Triggers a garbage collection in all containers
@throws BadRequest None
"""
self.perform_action(ALL_CONTAINERS_INSTANCE,
IonObject(OT.TriggerGarbageCollection))
def reset_policy_cache(self, headers=None, timeout=None):
"""Clears and reloads the policy caches in all of the containers.
@throws BadRequest None
"""
self.perform_action(ALL_CONTAINERS_INSTANCE,
IonObject(OT.ResetPolicyCache))
def set_log_level(self, logger='', level='', recursive=False):
self.perform_action(
ALL_CONTAINERS_INSTANCE,
IonObject(OT.ChangeLogLevel,
logger=logger,
level=level,
recursive=recursive))
def _create_resource(self, restype, name, *args, **kwargs):
res_obj = IonObject(restype, dict(name=name, **kwargs))
res_obj_res = self.data_store.create(res_obj,
create_unique_resource_id())
res_obj._id = res_obj_res[0]
self.resources[name] = res_obj
return res_obj_res[0]
def set_configuration(self, config):
log.warn("DRIVER: set_configuration")
"""
expect configuration to have:
- parser module/class
- directory, wildcard to find data files
- optional timestamp of last granule
- optional poll rate
- publish info
"""
log.error("Log level: %s", log.getEffectiveLevel())
log.debug('using configuration: %s', config)
self.config = config
self.max_records = get_safe(config, 'max_records', 100)
self.stream_config = self.CFG.get('stream_config', {})
if len(self.stream_config) == 1:
stream_cfg = self.stream_config.values()[0]
elif len(self.stream_config) > 1:
stream_cfg = self.stream_config.values()[0]
stream_id = stream_cfg['stream_id']
stream_route = IonObject(OT.StreamRoute,
routing_key=stream_cfg['routing_key'],
exchange_point=stream_cfg['exchange_point'])
param_dict = stream_cfg['stream_def_dict']['parameter_dictionary']
self.publisher = StandaloneStreamPublisher(stream_id=stream_id,
stream_route=stream_route)
self.parameter_dictionary = ParameterDictionary.load(param_dict)
self.time_field = self.parameter_dictionary.get_temporal_context()
self.latest_granule_time = get_safe(config, 'last_time', 0)
def test_rr_create_with_id(self):
res_obj1 = IonObject(RT.Org)
newid = uuid.uuid4().hex
rid1,_ = self.rr.create(res_obj1, object_id=newid)
self.assertEqual(rid1, newid)
def test_garbage_collection_handler(self):
""" initial log level for ion.process.event is INFO -- test we can change it to TRACE """
#
handler = pyon.container.management.GarbageCollectionHandler()
action = IonObject(OT.TriggerGarbageCollection)
handler.handle_request(action)
def _execute(self, cprefix, command):
if not command:
raise iex.BadRequest("execute argument 'command' not present")
if not command.command:
raise iex.BadRequest("command not set")
cmd_res = IonObject("AgentCommandResult", command_id=command.command_id, command=command.command)
cmd_func = getattr(self, cprefix + str(command.command), None)
if cmd_func:
cmd_res.ts_execute = get_ion_ts()
try:
res = cmd_func(*command.args, **command.kwargs)
cmd_res.status = 0
cmd_res.result = res
except iex.IonException as ex:
# TODO: Distinguish application vs. uncaught exception
cmd_res.status = getattr(ex, 'status_code', -1)
cmd_res.result = str(ex)
log.warn("Agent command %s failed with trace=%s" % (command.command, traceback.format_exc()))
else:
log.info("Agent command not supported: %s" % (command.command))
ex = iex.NotFound("Command not supported: %s" % command.command)
cmd_res.status = iex.NotFound.status_code
cmd_res.result = str(ex)
sub_type = "%s.%s" % (command.command, cmd_res.status)
post_event = self._event_publisher._create_event(event_type=self.COMMAND_EVENT_TYPE,
origin=self.resource_id, origin_type=self.ORIGIN_TYPE,
sub_type=sub_type, command=command, result=cmd_res)
post_event = self._post_execute_event_hook(post_event)
success = self._event_publisher._publish_event(post_event, origin=post_event.origin)
return cmd_res
def get_resource_object(self,
my_resource_id,
resource_name='TestSystem_Resource'):
'''
Method used for testing
'''
return IonObject(RT.SystemResource, name=resource_name)
def xtest_policy_cache_handler(self):
""" initial log level for ion.process.event is INFO -- test we can change it to TRACE """
#
handler = pyon.container.management.PolicyCacheHandler()
action = IonObject(OT.ResetPolicyCache)
handler.handle_request(action)
def test_read_negotiation(self):
negotiation_handler = Negotiation(self)
with self.assertRaises(BadRequest) as cm:
negotiation_handler.read_negotiation()
self.assertIn(
'The sap parameter must be a valid Service Agreement Proposal object',
cm.exception.message)
sap = IonObject(OT.EnrollmentProposal,
consumer=self.actor_identity._id,
provider=self.org._id)
with self.assertRaises(BadRequest) as cm:
negotiation_handler.read_negotiation(sap)
self.assertIn(
'The Service Agreement Proposal object (sap) is missing a negotiation_id value',
cm.exception.message)
negotiation = Mock()
negotiation._id = '456'
sap.negotiation_id = negotiation._id
self.mock_read.return_value = negotiation
neg_obj = negotiation_handler.read_negotiation(sap)
self.assertEqual(neg_obj, negotiation)
def test_get_valid_org_commitment(self):
from pyon.util.containers import get_ion_ts_millis
# create ION org and an actor
ion_org = IonObject(RT.Org, name='ION')
ion_org_id, _ = self.rr.create(ion_org)
ion_org._id = ion_org_id
actor = IonObject(RT.ActorIdentity, name='actor1')
actor_id, _ = self.rr.create(actor)
device = IonObject(RT.TestDevice, name="device1")
device_id, _ = self.rr.create(device)
# create an expired commitment in the org
ts = get_ion_ts_millis() - 50000
com_obj = IonObject(RT.Commitment,
provider=ion_org_id,
consumer=actor_id,
commitment=True,
expiration=ts)
com_id, _ = self.rr.create(com_obj)
self.rr.create_association(ion_org_id, PRED.hasCommitment, com_id)
c = get_valid_principal_commitments(ion_org_id, actor_id)
# verify that the commitment is not returned
self.assertIsNone(c)
self.rr.create_association(com_id, PRED.hasTarget, device_id)
c = get_valid_resource_commitments(device_id, actor_id)
# verify that the commitment is not returned
self.assertIsNone(c)
# create a commitment that has not expired yet
ts = get_ion_ts_millis() + 50000
com_obj = IonObject(RT.Commitment,
provider=ion_org_id,
consumer=actor_id,
commitment=True,
expiration=ts)
com_id, _ = self.rr.create(com_obj)
self.rr.create_association(ion_org_id, PRED.hasCommitment, com_id)
c = get_valid_principal_commitments(ion_org_id, actor_id)
# verify that the commitment is returned
self.assertIsNotNone(c)
self.rr.create_association(com_id, PRED.hasTarget, device_id)
c = get_valid_resource_commitments(device_id, actor_id)
# verify that the commitment is not returned
self.assertIsNotNone(c)
def create_test_col(level=0, ot=dict, no_ion=False):
if level == 0:
return get_value(0, 15, uvals)
if ot == dict:
res_dict = {}
num_kinds = 1 if do_ion and no_ion else (1 if do_dict else 0) + (
1 if do_list else 0)
for i in xrange(breadth / num_kinds):
if do_ion and not no_ion:
key = get_key()
res_obj = IonObject(restype,
name="TestObject %s.%s" % (level, key))
res_obj.addl = create_test_col(level - 1,
dict,
no_ion=True)
res_dict[key] = res_obj
else:
if do_dict:
res_dict[get_key()] = create_test_col(level - 1, dict)
if do_list:
res_dict[get_key()] = create_test_col(level - 1, list)
return res_dict
elif ot == list:
res_list = []
num_kinds = 1 if do_ion and no_ion else (1 if do_dict else 0) + (
1 if do_list else 0)
for i in xrange(breadth / num_kinds):
if do_ion and not no_ion:
res_obj = IonObject(restype,
name="TestObject %s.%s" %
(level, random.randint(1000, 9999)))
res_obj.addl = create_test_col(level - 1,
dict,
no_ion=True)
res_list.append(res_obj)
else:
if do_dict:
res_list.append(create_test_col(level - 1, dict))
if do_list:
res_list.append(create_test_col(level - 1, list))
return res_list
elif ot == "IonObject":
res_obj = IonObject(restype,
name="TestObject %s.%s" %
(level, random.randint(1000, 9999)))
return res_obj
def test_get_sytsem_actor_header(self):
actor = IonObject(RT.ActorIdentity, name='ionsystem')
actor_id, _ = self.rr.create(actor)
system_actor_header = get_system_actor_header()
self.assertDictEqual(system_actor_header['ion-actor-roles'],
{'ION': [MEMBER_ROLE]})
def fun():
#ret = Mock()
self.log.debug("Creating sample %s" % impl.iontype)
ret = IonObject(impl.iontype)
ret.name = "sample %s" % impl.iontype
ret.description = "description of sample %s" % impl.iontype
for k, v in resource_params.iteritems():
setattr(ret, k, v)
return ret
def svcmethod(self, *args, **kwargs):
assert len(
args
) == 0, "You MUST used named keyword args when calling a dynamically generated remote method" # we have no way of getting correct order
headers = kwargs.pop(
'headers', None
) # pull headers off, cannot put this in the signature due to *args for ordering
ionobj = IonObject(in_obj, **kwargs)
return self.request(ionobj, op=name, headers=headers)
def set_computed_attributes(self, res_container, computed_resource_type,
ext_exclude):
if not computed_resource_type or computed_resource_type is None:
return
res_container.computed = IonObject(computed_resource_type)
self.set_object_field_values(res_container.computed,
res_container.resource, ext_exclude)
def on_init(self):
IonObject("Resource") # suppress pyflakes error
self.override_clients(self.clients)
self.init_module_uploader()
self.get_unique_id = (lambda: uuid4().hex)
self.data_product_management = DataProductManagementServiceClient()
def set_computed_attributes(self, res_container, computed_resource_type, ext_exclude, **kwargs):
"""
Creates the specified ComputedAttributes object if given and iterate over the fields
to set the computed values.
"""
if not computed_resource_type or computed_resource_type is None:
return
res_container.computed = IonObject(computed_resource_type)
self.set_object_field_values(res_container.computed, res_container.resource, ext_exclude, **kwargs)
def obtain_agent_calculation(self, device_id, result_container):
ret = IonObject(result_container)
h_agent, reason = self.get_device_agent(device_id)
if None is h_agent:
ret.status = ComputedValueAvailability.NOTAVAILABLE
ret.reason = reason
else:
ret.status = ComputedValueAvailability.PROVIDED
return h_agent, ret
def test_logging_handler(self):
""" initial log level for ion.process.event is INFO -- test we can change it to TRACE """
config.replace_configuration(os.path.join(TEST_DIR, 'logging.yml'))
log.debug('this should probably not be logged')
self.assertFalse(log.isEnabledFor(TRACE))
#
handler = pyon.container.management.LogLevelHandler()
action = IonObject(OT.ChangeLogLevel, logger='pyon.container', level='TRACE')
handler.handle_request(action)
#
self.assertTrue(log.isEnabledFor(TRACE))
def create_role_request(self, org_id, user_id, role_name):
request_object = IonObject(RT.RoleRequest,
name='Role Request',
org_id=org_id,
user_id=user_id,
role_name=role_name,
status="Initialized",
description='%s Role Request at %s' %
(user_id, str(now)))
return request_object
def create_enrollment_request(self, org_id, user_id):
request_object = IonObject(
RT.EnrollmentRequest,
name='Enroll Request',
org_id=org_id,
user_id=user_id,
status="Initialized",
description='%s Org Enrollment Request at %s' %
(user_id, str(now)))
return request_object
def xtest_logging_root(self):
""" initial root log level is WARN -- test that we can change it to ERROR """
config.replace_configuration(os.path.join(TEST_DIR, 'logging.yml'))
otherlog = logging.getLogger('pyon.container')
self.assertTrue(otherlog.isEnabledFor(logging.WARN))
#
handler = pyon.container.management.LogLevelHandler()
action = IonObject(OT.ChangeLogLevel, logger='pyon', level='ERROR')
handler.handle_request(action)
#
self.assertFalse(otherlog.isEnabledFor(logging.WARN))
def test_encode_decode(self):
obj = IonObject(RT.InstrumentDevice, name='SBE37IMDevice', description="SBE37IMDevice", serial_number="12345" )
d = self.subject.encode(obj)
print 'keys: ' + repr(d)
self.assertFalse('_id' in d.keys())
new_obj = self.subject.decode(d)
self.assertEqual(obj, new_obj)
d2 = self.subject.encode(new_obj, add_id=True)
self.assertTrue('_id' in d2.keys(), msg=repr(d2.keys()))
# retains key once added
d3 = self.subject.encode(self.subject.decode(d2))
self.assertTrue('_id' in d3.keys())
def create_acquire_resource(self, org_id, user_id, resource_id):
request_object = IonObject(
RT.ResourceRequest,
name='Acquire Resource Request',
org_id=org_id,
user_id=user_id,
resource_id=resource_id,
status="Initialized",
description='%s Acquire Resource Request at %s' %
(user_id, str(now)))
return request_object
def test_validate(self):
obj = self.registry.new('SampleObject')
self.name = 'monkey'
self.int = 1
obj._validate()
obj.name = 3
self.assertRaises(AttributeError, obj._validate)
# TEST: setattr validation
obj.name = 'monkey'
with self.assertRaises(AttributeError):
obj.extra_field = 5
# TEST: Validate of object inheritance
taskable_resource = self.registry.new('TaskableResource')
taskable_resource.name = "Fooy"
obj.abstract_val = taskable_resource
self.assertRaises(AttributeError, obj._validate)
exec_res = self.registry.new('ExecutableResource')
exec_res.name = "Fooy"
obj.abstract_val = exec_res
obj._validate()
# TEST: Validate of object inheritance in message objects
from interface.messages import resource_registry_create_in
msg_obj = resource_registry_create_in()
msg_obj.object = IonObject("Resource", name="foo")
msg_obj._validate()
msg_obj.object = IonObject("InformationResource", name="foo")
msg_obj._validate()
msg_obj.object = IonObject("TestInstrument", name="foo")
msg_obj._validate()
msg_obj.object = IonObject("Association")
self.assertRaises(AttributeError, msg_obj._validate)
