def delete_exchange_point(self, exchange_point_id=''):
        """Delete an existing exchange point resource.

        @param exchange_point_id    str
        @throws NotFound    object with specified id does not exist
        """
        exchange_point = self.clients.resource_registry.read(exchange_point_id)
        if not exchange_point:
            raise NotFound("Exchange Point %s does not exist" %
                           exchange_point_id)

        # get associated XS first
        exchange_space_list, assoc_list = self.clients.resource_registry.find_subjects(
            RT.ExchangeSpace, PRED.hasExchangePoint, exchange_point_id)
        if not len(exchange_space_list) == 1:
            raise NotFound(
                "Associated Exchange Space to Exchange Point %s does not exist"
                % exchange_point_id)

        exchange_space = exchange_space_list[0]

        # delete association to XS
        for assoc in assoc_list:
            self.clients.resource_registry.delete_association(assoc._id)

        # delete from RR
        self.clients.resource_registry.delete(exchange_point_id)

        # call container API
        xs = exchange.ExchangeSpace(self.container.ex_manager,
                                    exchange_space.name)
        xp = exchange.ExchangePoint(self.container.ex_manager,
                                    exchange_point.name, xs, 'ttree')
        self.container.ex_manager.delete_xp(xp, use_ems=False)
Ejemplo n.º 2
0
    def register_process_operation_precondition(self, process, operation,
                                                precondition):
        """
        This method is used to register process operation precondition functions
        with the governance controller. The endpoint code will call check_process_operation_preconditions()
        below before calling the business logic operation and if any of
        the precondition functions return False, then the request is denied as Unauthorized.

        At some point, this should be refactored to by another interceptor, but at the operation level.
        """
        if not hasattr(process, operation):
            raise NotFound(
                "The operation %s does not exist for the %s process" %
                (operation, process.name))

        if type(precondition
                ) == types.MethodType and precondition.im_self != process:
            raise NotFound("The method %s does not exist for the %s process." %
                           (str(precondition), process.name))

        process_op_conditions = self.get_process_operation_dict(process.name)
        if operation in process_op_conditions:
            process_op_conditions[operation].append(precondition)
        else:
            preconditions = list()
            preconditions.append(precondition)
            process_op_conditions[operation] = preconditions
    def add_resource_policy(self, resource_id='', policy_id=''):
        """Associates a policy rule to a specific resource

        @param resource_id    str
        @param policy_id    str
        @retval success    bool
        @throws NotFound    object with specified id does not exist
        """

        if not resource_id:
            raise BadRequest("The resource_id parameter is missing")

        resource = self.clients.resource_registry.read(resource_id)
        if not resource:
            raise NotFound("Resource %s does not exist" % resource_id)

        if not policy_id:
            raise BadRequest("The policy_id parameter is missing")

        policy = self.clients.resource_registry.read(policy_id)
        if not policy:
            raise NotFound("Policy %s does not exist" % policy_id)

        aid = self.clients.resource_registry.create_association(
            resource, PRED.hasPolicy, policy)
        if not aid:
            return False

        #Publish an event that the resource policy has changed
        self._publish_resource_policy_event(policy, resource)

        return True
    def remove_resource_policy(self, resource_id='', policy_id=''):
        """Removes an association for a policy rule to a specific resource

        @param resource_id    str
        @param policy_id    str
        @retval success    bool
        @throws NotFound    object with specified id does not exist
        """
        if not resource_id:
            raise BadRequest("The resource_id parameter is missing")

        resource = self.clients.resource_registry.read(resource_id)
        if not resource:
            raise NotFound("Resource %s does not exist" % resource_id)

        if not policy_id:
            raise BadRequest("The policy_id parameter is missing")

        policy = self.clients.resource_registry.read(policy_id)
        if not policy:
            raise NotFound("Policy %s does not exist" % policy_id)

        aid = self.clients.resource_registry.get_association(
            resource, PRED.hasPolicy, policy)
        if not aid:
            raise NotFound(
                "The association between the specified Resource %s and Policy %s was not found"
                % (resource_id, policy_id))

        self.clients.resource_registry.delete_association(aid)

        #Publish an event that the resource policy has changed
        self._publish_resource_policy_event(policy, resource)

        return True
Ejemplo n.º 5
0
    def register_process_operation_precondition(self, process, operation,
                                                precondition):

        if not hasattr(process, operation):
            raise NotFound(
                "The operation %s does not exist for the %s service" %
                (operation, process.name))

        if type(precondition
                ) == types.MethodType and precondition.im_self != process:
            raise NotFound("The method %s does not exist for the %s service." %
                           (str(precondition), process.name))
        elif type(precondition) == types.StringType:
            #Convert string to instancemethod if it exists..if not store as potential precondition to execute
            method = getattr(process, precondition, None)
            if method:
                precondition = method

        process_op_conditions = self.get_process_operation_dict(process.name)
        if process_op_conditions.has_key(operation):
            process_op_conditions[operation].append(precondition)
        else:
            preconditions = list()
            preconditions.append(precondition)
            process_op_conditions[operation] = preconditions
    def delete_user_info(self, user_info_id='', actor_identity_id=''):
        # Read UserInfo
        user_info = self.clients.resource_registry.read(user_info_id)
        if not user_info:
            raise NotFound("UserInfo %s does not exist" % user_info_id)
        # Find and break association with ActorIdentity
        if not actor_identity_id:
            subjects, assocs = self.clients.resource_registry.find_subjects(
                RT.ActorIdentity, PRED.hasInfo, user_info_id)
            if not assocs:
                raise NotFound(
                    "ActorIdentity to UserInfo association for user info id %s does not exist"
                    % user_info_id)
            actor_identity_id = subjects[0]._id

        assocs = self.clients.resource_registry.find_associations(
            actor_identity_id, PRED.hasInfo, user_info_id)
        if not assocs:
            raise NotFound(
                "ActorIdentity to UserInfo association for user info id %s does not exist"
                % user_info_id)
        association_id = assocs[0]._id

        self.clients.resource_registry.delete_association(association_id)
        # Delete the UserInfo
        self.clients.resource_registry.delete(user_info_id)
Ejemplo n.º 7
0
def acquire_data(hdf_files=None,
                 var_names=None,
                 concatenate_size=None,
                 bounds=None):

    import h5py, numpy

    if hdf_files is None:
        raise NotFound('No open_hdf_files provided to extract data from.')
    if var_names is None:
        raise NotFound('Variable names where not provided.')
    if concatenate_size is None:
        raise NotFound('The concatenation size was not provided')

    open_files = []

    try:
        for hdf_file in hdf_files:
            #-------------------------------------------------------------------------------------------------------
            # make a file object
            #-------------------------------------------------------------------------------------------------------
            try:
                file = h5py.File(hdf_file, 'r')
            except IOError as ioe:
                log.exception('Unable to open file: "%s"', hdf_file)

                # Try again?
                try:
                    file = h5py.File(hdf_file, 'r')

                except:
                    log.exception('Still Unable to open file: "%s" !',
                                  hdf_file)

                    # If we are only opening one file - we must fail - but otherwise for now, just let it go!
                    if len(hdf_files) == 1:
                        raise ioe

            open_files.append(file)

        gen = _acquire_hdf_data(open_hdf_files=open_files,
                                var_names=var_names,
                                concatenate_size=concatenate_size,
                                bounds=bounds)

        # run the generator yielding to the caller
        for item in gen:
            yield item

    finally:
        # always clean up!
        for file in open_files:
            file.close()
Ejemplo n.º 8
0
    def undeclare_exchange_name(self, canonical_name='', exchange_space_id=''):
        """Remove an exhange nane resource

        @param canonical_name    str
        @param exchange_space_id    str
        @retval success    bool
        @throws NotFound    object with specified id does not exist
        """
        # @TODO: currently we are using the exchange_name's id as the canonical name
        # and exchange_space_id is unused?
        exchange_name = self.container.resource_registry.read(canonical_name)
        if not exchange_name:
            raise NotFound("Exchange Name with id %s does not exist" %
                           canonical_name)

        exchange_name_id = exchange_name._id  # yes, this should be same, but let's make it look cleaner

        # get associated XS first
        exchange_space_list, assoc_list = self.container.resource_registry.find_subjects(
            RT.ExchangeSpace, PRED.hasExchangeName, exchange_name_id)
        if not len(exchange_space_list) == 1:
            raise NotFound(
                "Associated Exchange Space to Exchange Name %s does not exist"
                % exchange_name_id)

        exchange_space = exchange_space_list[0]

        # remove association between itself and XS
        _, assocs = self.container.resource_registry.find_subjects(
            RT.ExchangeSpace,
            PRED.hasExchangeName,
            exchange_name_id,
            id_only=True)
        for assoc in assocs:
            self.container.resource_registry.delete_association(assoc._id)

        # remove XN
        self.container.resource_registry.delete(exchange_name_id)

        # call container API
        xs = exchange.ExchangeSpace(
            self.container.ex_manager,
            self.container.ex_manager._priviledged_transport,
            exchange_space.name)
        xn = exchange.ExchangeName(
            self.container.ex_manager,
            self.container.ex_manager._priviledged_transport,
            exchange_name.name, xs)  # type doesn't matter here
        self.container.ex_manager.delete_xn(xn, use_ems=False)
Ejemplo n.º 9
0
 def read_doc(self, doc_id, rev_id="", datastore_name=""):
     ds, datastore_name = self._get_datastore(datastore_name)
     if not rev_id:
         log.debug('Reading head version of object %s/%s', datastore_name, doc_id)
         doc = ds.get(doc_id)
         if doc is None:
             raise NotFound('Object with id %s does not exist.' % str(doc_id))
     else:
         log.debug('Reading version %s of object %s/%s' ,rev_id, datastore_name, doc_id)
         doc = ds.get(doc_id, rev=rev_id)
         if doc is None:
             raise NotFound('Object with id %s does not exist.' % str(doc_id))
     log.debug('read doc contents: %s', doc)
     self._count(read=1)
     return doc
Ejemplo n.º 10
0
 def find_user_info_by_id(self, actor_id=''):
     # Look up UserInfo via association with ActorIdentity
     objects, assocs = self.clients.resource_registry.find_objects(actor_id, PRED.hasInfo, RT.UserInfo)
     if not objects:
         raise NotFound("UserInfo for user id %s does not exist" % actor_id)
     user_info = objects[0]
     return user_info
    def activate_subscription(self, subscription_id=''):
        '''
        Bind a subscription using a channel layer.

        @param subscription_id The id of the subscription.
        @retval success Boolean to indicate successful activation.
        @throws NotFound when subscription doesn't exist.
        '''
        log.debug("Activating subscription")
        subscription_obj = self.clients.resource_registry.read(subscription_id)
        if subscription_obj is None:
            raise NotFound("Subscription %s does not exist" % subscription_id)

        if subscription_obj.is_active:
            raise BadRequest('Subscription is already active!')

        ids, _ = self.clients.resource_registry.find_objects(subscription_id,
                                                             PRED.hasStream,
                                                             RT.Stream,
                                                             id_only=True)

        if subscription_obj.subscription_type == SubscriptionTypeEnum.STREAM_QUERY:
            for stream_id in ids:
                self._bind_subscription(self.XP,
                                        subscription_obj.exchange_name,
                                        stream_id + '.data')
        elif subscription_obj.subscription_type == SubscriptionTypeEnum.EXCHANGE_QUERY:
            self._bind_subscription(self.XP, subscription_obj.exchange_name,
                                    '*.data')

        subscription_obj.is_active = True

        self.clients.resource_registry.update(object=subscription_obj)

        return True
    def get_active_resource_policy_rules(self, resource_id=''):
        """Generates the set of all enabled policies for the specified resource

        @param resource_id    str
        @retval policy    str
        @throws NotFound    object with specified id does not exist
        """
        if not resource_id:
            raise BadRequest("The resource_id parameter is missing")

        resource = self.clients.resource_registry.read(resource_id)
        if not resource:
            raise NotFound("Resource %s does not exist" % resource_id)

        policy = self._get_policy_template()

        #TODO - investigate better ways to optimize this
        rules = ""
        policy_set = self.find_resource_policies(resource_id)

        for p in policy_set:
            if p.enabled:
                rules += p.rule

        policy_rules = policy % ('', resource_id, rules)

        return policy_rules
Ejemplo n.º 13
0
 def read_doc(self, doc_id, rev_id=None, datastore_name=None):
     """"
     Fetch a raw doc instance.  If rev_id is specified, an attempt
     will be made to return that specific doc version.  Otherwise,
     the HEAD version is returned.
     """
     ds, datastore_name = self._get_datastore(datastore_name)
     if not rev_id:
         doc = ds.get(doc_id)
         if doc is None:
             raise NotFound('Object with id %s does not exist.' % doc_id)
     else:
         doc = ds.get(doc_id, rev=rev_id)
         if doc is None:
             raise NotFound('Object with id %s does not exist.' % doc_id)
     return doc
    def delete_persistence_instance(self, persistence_instance_id=''):
        """delete a PersistenceInstance resource from the resource registry
           remove any associations with the PersistenceInstance (Datastores or PersistenceSystems)

        @param persistence_instance_id    str
        @throws NotFound    resource with specified id does not exist
        """
        persistence_instance = self.clients.resource_registry.read(
            persistence_instance_id)
        if persistence_instance is None:
            raise NotFound("PersistenceInstance %s does not exist" %
                           persistence_instance_id)

        assocs = self.clients.resource_registry.find_associations(
            subject=persistence_instance_id, assoc_type=PRED.hasDatastore)
        for assoc in assocs:
            self.clients.resource_registry.delete_association(
                assoc._id)  # Find and break association with Datastore

        assocs = self.clients.resource_registry.find_associations(
            predicate=persistence_instance_id,
            assoc_type=PRED.hasPersistenceInstance)
        for assoc in assocs:
            self.clients.resource_registry.delete_association(
                assoc._id)  # Find and break association with PersistenceSystem

        self.clients.resource_registry.delete(persistence_instance_id)
Ejemplo n.º 15
0
    def cancel_member_enrollment(self, org_id='', user_id=''):
        """Cancels the membership of a specified user within the specified Org. Once canceled, the user will no longer
        have access to the resource of that Org. Throws a NotFound exception if neither id is found.

        @param org_id    str
        @param user_id    str
        @retval success    bool
        @throws NotFound    object with specified id does not exist
        """
        param_objects = self._validate_parameters(org_id=org_id,
                                                  user_id=user_id)
        org = param_objects['org']
        user = param_objects['user']

        if org.name == ROOT_ION_ORG_NAME:
            raise BadRequest(
                "A request to cancel enrollment in the root ION Org is not allowed"
            )

        #First remove all associations to any roles
        role_list = self.find_roles_by_user(org_id, user_id)
        for user_role in role_list:
            self._delete_role_association(org, user, user_role)

        #Finally remove the association to the Org
        aid = self.clients.resource_registry.get_association(
            org, PRED.hasMembership, user)
        if not aid:
            raise NotFound(
                "The membership association between the specified user and Org is not found"
            )

        self.clients.resource_registry.delete_association(aid)
        return True
Ejemplo n.º 16
0
    def unregister_process_operation_precondition(self, process, operation,
                                                  precondition):

        #Just skip this if there operation is not passed in.
        if operation is None:
            return

        if not hasattr(process, operation):
            raise NotFound(
                "The operation %s does not exist for the %s service" %
                (operation, process.name))

        if type(precondition) == types.StringType:
            #Convert string to instancemethod
            method = getattr(process, precondition, None)
            if method:
                precondition = method

        process_op_conditions = self.get_process_operation_dict(process.name)
        if process_op_conditions.has_key(operation):
            preconditions = process_op_conditions[operation]
            preconditions[:] = [
                pre for pre in preconditions if not pre == precondition
            ]
            if not preconditions:
                del process_op_conditions[operation]
Ejemplo n.º 17
0
    def unregister_process_operation_precondition(self, process, operation,
                                                  precondition):
        """
        This method removes a specific precondition function registered with an operation on a process.
        Care should be taken with this call, as it can remove "hard wired" preconditions that are
        directly registered by processes in a container.
        """
        #Just skip this if there operation is not passed in.
        if operation is None:
            return

        if not hasattr(process, operation):
            raise NotFound(
                "The operation %s does not exist for the %s service" %
                (operation, process.name))

        process_op_conditions = self.get_process_operation_dict(process.name,
                                                                auto_add=False)
        if process_op_conditions is not None and operation in process_op_conditions:
            preconditions = process_op_conditions[operation]
            preconditions[:] = [
                pre for pre in preconditions if not pre == precondition
            ]
            if not preconditions:
                del process_op_conditions[operation]
    def create_exchange_space(self, exchange_space=None, org_id=''):
        """Creates an Exchange Space distributed resource from the parameter exchange_space object.

        @param exchange_space    ExchangeSpace
        @param org_id    str
        @retval exchange_space_id    str
        @throws BadRequest    if object passed has _id or _rev attribute
        """
        log.debug("create_exchange_space(%s, org_id=%s)" %
                  (exchange_space, org_id))
        self.assert_condition(exchange_space and org_id, "Arguments not set")

        #First make sure that Org with the org_id exists, otherwise bail
        org = self.clients.resource_registry.read(org_id)
        if not org:
            raise NotFound("Org %s does not exist" % org_id)

        exchange_space_id, rev = self.clients.resource_registry.create(
            exchange_space)

        aid = self.clients.resource_registry.create_association(
            org_id, PRED.hasExchangeSpace, exchange_space_id)

        # Now do the work

        #        if exchange_space.name == "ioncore":
        #            # Bottom turtle initialization
        #            # @TODO: what's different here
        #            self.container.ex_manager.create_xs(exchange_space.name)
        #        else:
        self.container.ex_manager.create_xs(exchange_space.name, use_ems=False)

        return exchange_space_id
Ejemplo n.º 19
0
 def read_subject(self,
                  subject_type="",
                  predicate="",
                  object="",
                  assoc="",
                  id_only=False):
     if assoc:
         if type(assoc) is str:
             assoc = self.read(assoc)
         return assoc.s if id_only else self.read(assoc.s)
     else:
         sub_list, assoc_list = self.find_subjects(
             subject_type=subject_type,
             predicate=predicate,
             object=object,
             id_only=True)
         if not sub_list:
             raise NotFound(
                 "No subject found for subject_type=%s, predicate=%s, object=%s"
                 % (subject_type, predicate, object))
         elif len(sub_list) > 1:
             raise Inconsistent(
                 "More than one subject found for subject_type=%s, predicate=%s, object=%s: count=%s"
                 % (subject_type, predicate, object, len(sub_list)))
         return sub_list[0] if id_only else self.read(sub_list[0])
Ejemplo n.º 20
0
 def find_user_info_by_name(self, name=''):
     objects, matches = self.clients.resource_registry.find_resources(RT.UserInfo, None, name, id_only=False)
     if not objects:
         raise NotFound("UserInfo with name %s does not exist" % name)
     if len(objects) > 1:
         raise Inconsistent("Multiple UserInfo objects with name %s exist" % name)
     return objects[0]
Ejemplo n.º 21
0
    def buy_bonds(self, account_id='', cash_amount=0.0):
        """
        Purchase the specified amount of bonds.  Check is first made
        that the cash account has sufficient funds.
        """
        account_obj = self.clients.resource_registry.read(account_id)
        if not account_obj:
            raise NotFound("Account %s does not exist" % account_id)
        if account_obj.cash_balance < cash_amount:
            raise BadRequest("Insufficient funds")

        owner_obj = self.clients.resource_registry.find_subjects(
            "BankCustomer", PRED.hasAccount, account_obj, False)[0][0]
        # Create order object and call trade service
        order_obj = IonObject("Order",
                              type="buy",
                              on_behalf=owner_obj.name,
                              cash_amount=cash_amount)

        # Make the call to trade service
        confirmation_obj = self.clients.trade.exercise(order_obj)

        if confirmation_obj.status == "complete":
            account_obj.cash_balance -= cash_amount
            account_obj.bond_balance += confirmation_obj.proceeds
            self.clients.resource_registry.update(account_obj)
            return "Balances after bond purchase: cash %f, bonds: %s" % (
                account_obj.cash_balance, account_obj.bond_balance)
        return "Bond purchase status is: %s" % confirmation_obj.status
Ejemplo n.º 22
0
    def get_user_info_extension(self, user_info_id='', user_id=''):
        """Returns an UserInfoExtension object containing additional related information

        @param user_info_id    str
        @retval user_info    UserInfoExtension
        @throws BadRequest    A parameter is missing
        @throws NotFound    An object with the specified actor_id does not exist
        """
        if not user_info_id:
            raise BadRequest("The user_info_id parameter is empty")

        extended_resource_handler = ExtendedResourceContainer(self)
        extended_user = extended_resource_handler.create_extended_resource_container(
            extended_resource_type=OT.UserInfoExtension,
            resource_id=user_info_id,
            user_id=user_id)

        #If the org_id is not provided then skip looking for Org related roles.
        if extended_user:
            #Did not setup a dependency to org_management service to avoid a potential circular bootstrap issue
            # since this method should never be called until the system is fully running
            try:
                org_client = OrgManagementServiceProcessClient(process=self)
                roles = org_client.find_all_roles_by_user(extended_user.actor_identity._id)
                extended_user.roles = list()
                for org_name in roles:
                    for role in roles[org_name]:
                        flattened_role = copy.copy(role.__dict__)
                        del flattened_role['type_']  #Have to do this to appease the message validators for ION objects
                        flattened_role['org_name'] = org_name  #Nothing like forcing a value into the dict to appease the UI code
                        extended_user.roles.append(flattened_role)

            except Exception, e:
                raise NotFound('Could not retrieve UserRoles for User Info id: %s - %s' % (user_info_id, e.message))
Ejemplo n.º 23
0
    def delete_doc(self, doc, datastore_name="", del_associations=False):
        ds, datastore_name = self._get_datastore(datastore_name)
        doc_id = doc if type(doc) is str else doc["_id"]
        log.debug('Deleting object %s/%s', datastore_name, doc_id)

        if del_associations:
            assoc_ids = self.find_associations(anyobj=doc_id, id_only=True)
            self.delete_doc_mult(assoc_ids)
#            for aid in assoc_ids:
#                self.delete(aid, datastore_name=datastore_name)
#            log.info("Deleted %n associations for object %s", len(assoc_ids), doc_id)

        elif self._is_in_association(doc_id, datastore_name):
            bad_doc = self.read(doc_id)
            if doc:
                log.warn("XXXXXXX Attempt to delete %s object %s that still has associations" % (bad_doc.type_, doc_id))
            else:
                log.warn("XXXXXXX Attempt to delete object %s that still has associations" % doc_id)
#           raise BadRequest("Object cannot be deleted until associations are broken")

        try:
            if type(doc) is str:
                del ds[doc_id]
            else:
                ds.delete(doc)
            self._count(delete=1)
        except ResourceNotFound:
            raise NotFound('Object with id %s does not exist.' % doc_id)
Ejemplo n.º 24
0
 def unregister_user_credentials(self, actor_id='', credentials_name=''):
     # Read UserCredentials
     objects, matches = self.clients.resource_registry.find_resources(RT.UserCredentials, None, credentials_name, id_only=False)
     if not objects or len(objects) == 0:
         raise NotFound("UserCredentials %s does not exist" % credentials_name)
     if len(objects) > 1:
         raise Conflict("Multiple UserCredentials objects found for subject %s" % credentials_name)
     user_credentials_id = objects[0]._id
     # Find and break association with ActorIdentity
     assocs = self.clients.resource_registry.find_associations(actor_id, PRED.hasCredentials, user_credentials_id)
     if not assocs or len(assocs) == 0:
         raise NotFound("ActorIdentity to UserCredentials association for user id %s to credential %s does not exist" % (actor_id, credentials_name))
     association_id = assocs[0]._id
     self.clients.resource_registry.delete_association(association_id)
     # Delete the UserCredentials
     self.clients.resource_registry.delete(user_credentials_id)
    def delete_datastore(self, datastore_id=''):
        """delete a datastore resource from the resource registry
           remove any associations with the datastore (PersistenceSystems or PersistenceInstances)

        @param datastore_id    str
        @throws NotFound    object with specified id does not exist
        """
        datastore = self.clients.resource_registry.read(datastore_id)
        if datastore is None:
            raise NotFound("Datastore %s does not exist" % datastore_id)

        assocs = self.clients.resource_registry.find_associations(
            object=datastore_id, assoc_type=PRED.hasDatastore)
        for assoc in assocs:
            self.clients.resource_registry.delete_association(
                assoc._id)  # Find and break association with PersistenceSystem

        assocs = self.clients.resource_registry.find_associations(
            subject=datastore_id, assoc_type=PRED.hasArchive)
        for assoc in assocs:
            self.clients.resource_registry.delete_association(
                assoc._id
            )  # Find and break association with PersistentArchvies

        self.clients.resource_registry.delete(datastore_id)
    def _get_base_parameter(self, data_product_id, parameter_name):
        # Get the parameter
        parameters = self.data_product_management.get_data_product_parameters(
            data_product_id)
        parameter_obj = None
        for parameter in parameters:
            if parameter.name == parameter_name:
                parameter_obj = parameter
                break

        if parameter_obj is None:  # Still None
            raise NotFound("Data product %s doesn't have a parameter %s" %
                           (data_product_id, parameter_name))

        # Get the DPS Code
        dps_code = parameter.ooi_short_name
        if not dps_code:
            raise BadRequest(
                "Parameter %s (%s) has no defined data product code" %
                (parameter.name, parameter._id))

        # Make the dps_code + _l1b_pd

        if re.match(r'.*_L[0-2]', dps_code):
            print "matches"
            dps_code = dps_code[:-3]
        return dps_code, parameter
Ejemplo n.º 27
0
    def delete_doc(self, doc, datastore_name=""):
        if not datastore_name:
            datastore_name = self.datastore_name
        try:
            datastore_dict = self.root[datastore_name]
        except KeyError:
            raise BadRequest('Data store ' + datastore_name +
                             ' does not exist.')

        if type(doc) is str:
            object_id = doc
        else:
            object_id = doc["_id"]

        log.info('Deleting object %s/%s' % (datastore_name, object_id))
        if object_id in datastore_dict.keys():

            if self._is_in_association(object_id, datastore_name):
                obj = self.read(object_id, "", datastore_name)
                log.warn(
                    "XXXXXXX Attempt to delete object %s that still has associations"
                    % str(obj))
#                raise BadRequest("Object cannot be deleted until associations are broken")

# Find all version dicts and delete them
            for key in datastore_dict.keys():
                if key.find(object_id + '_version_') == 0:
                    del datastore_dict[key]
            # Delete the HEAD dict
            del datastore_dict[object_id]
            # Delete the version counter dict
            del datastore_dict['__' + object_id + '_version_counter']
        else:
            raise NotFound('Object with id ' + object_id + ' does not exist.')
        log.info('Delete result: True')
 def read_data_process(self, data_process_id=""):
     # Read DataProcess object with _id matching  id
     log.debug("Reading DataProcess object id: %s" % data_process_id)
     data_proc_obj = self.clients.resource_registry.read(data_process_id)
     if not data_proc_obj:
         raise NotFound("DataProcess %s does not exist" % data_process_id)
     return data_proc_obj
    def test_assign_single_subject(self):
        x = "x_id"
        y = "y_id"

        def rst():
            self.rr.find_subjects.reset_mock()
            self.rr.get_association.reset_mock()

        rst()
        self.rr.find_subjects.return_value = ([], [])
        self.RR2.assign_instrument_device_to_one_instrument_site(y, x)
        self.rr.create_association.assert_called_once_with(
            x, PRED.hasDevice, y)

        rst()
        self.rr.find_subjects.return_value = (["a", "b"], ["c", "d"])
        self.assertRaises(
            Inconsistent,
            self.RR2.assign_instrument_device_to_one_instrument_site, y, x)

        rst()
        self.rr.find_subjects.return_value = (["a"], ["b"])
        self.rr.get_association.return_value = "yay"
        self.RR2.assign_instrument_device_to_one_instrument_site(y, x)

        rst()
        self.rr.find_subjects.return_value = (["a"], ["b"])
        self.rr.get_association.side_effect = NotFound("")
        self.assertRaises(
            BadRequest,
            self.RR2.assign_instrument_device_to_one_instrument_site, y, x)
    def deactivate_ingestion_configuration(self,
                                           ingestion_configuration_id=''):
        """Deactivate one of the transform processes that uses an ingestion configuration

        @param ingestion_configuration_id    str
        @throws NotFound    The ingestion configuration id did not exist
        """
        log.debug("Deactivating ingestion configuration")

        # check whether the ingestion configuration object exists
        #ingestion_configuration = self.read_ingestion_configuration(ingestion_configuration_id)
        #@todo Should we check to see if the ingestion configuration exists?

        # use the deactivate method in transformation management service
        transform_ids, _ = self.clients.resource_registry.find_objects(
            ingestion_configuration_id, PRED.hasTransform, RT.Transform, True)
        if len(transform_ids) < 1:
            raise NotFound('The ingestion configuration %s does not exist' %
                           str(ingestion_configuration_id))

        # since all ingestion worker transforms have the same subscription, only deactivate one
        self.clients.transform_management.deactivate_transform(
            transform_ids[0])

        return True