Example #1
0
 def populate(self):
     manager = factory.consumer_manager()
     for id in self.CONSUMER_IDS:
         manager.register(id)
     manager = factory.consumer_profile_manager()
     for id in self.CONSUMER_IDS:
         manager.create(id, 'rpm', self.PROFILE)
Example #2
0
 def units_applicable(self, criteria, units):
     """
     Detemine and report which of the specified content units
     is applicable to consumers specified by the I{criteria}.
     @param criteria: The consumer selection criteria.
     @type criteria: list
     @param units: A list of content units to be installed.
     @type units: list of:
         { type_id:<str>, unit_key:<dict> }
     @return: A dict:
         {consumer_id:[<ApplicabilityReport>]}
     @rtype: list
     """
     result = {}
     conduit = ProfilerConduit()
     manager = managers.consumer_query_manager()
     ids = [c['id'] for c in manager.find_by_criteria(criteria)]
     manager = managers.consumer_profile_manager()
     profiles = manager.find_profiles(ids)
     for id in ids:
         for unit in units:
             typeid = unit['type_id']
             profiler, cfg = self.__profiler(typeid)
             pc = self.__profiled_consumer(id)
             report = profiler.unit_applicable(pc, unit, cfg, conduit)
             report.unit = unit
             ulist = result.setdefault(id, [])
             ulist.append(report)
     return result
Example #3
0
    def PUT(self, consumer_id, content_type):
        """
        Update the association of a profile with a consumer by content type ID.
        @param consumer_id: A consumer ID.
        @type consumer_id: str
        @param content_type: A content unit type ID.
        @type content_type: str
        @return: The updated model object:
            {consumer_id:<str>, content_type:<str>, profile:<dict>}
        @rtype: dict
        """
        body = self.params()
        profile = body.get('profile')

        manager = managers.consumer_profile_manager()
        tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
                resource_tag(dispatch_constants.RESOURCE_CONTENT_UNIT_TYPE, content_type),
                action_tag('profile_update')]

        call_request = CallRequest(manager.update,
                                   [consumer_id, content_type],
                                   {'profile': profile},
                                   tags=tags,
                                   weight=0,
                                   kwarg_blacklist=['profile'])
        call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)

        call_report = CallReport.from_call_request(call_request)
        call_report.serialize_result = False

        consumer = execution.execute_sync(call_request, call_report)
        link = serialization.link.child_link_obj(consumer_id, content_type)
        consumer.update(link)

        return self.ok(consumer)
Example #4
0
    def post(self, request, consumer_id):
        """
        Associate a profile with a consumer by content type ID.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: A consumer ID.
        :type consumer_id: str

        :raises MissingValue: if some parameter were not provided

        :return: Response representing the created profile
        :rtype: django.http.HttpResponse
        """

        body = request.body_as_json
        content_type = body.get('content_type')
        profile = body.get('profile')

        manager = factory.consumer_profile_manager()
        new_profile = manager.create(consumer_id, content_type, profile)
        if content_type is None:
            raise MissingValue('content_type')
        link = add_link_profile(new_profile)
        response = generate_json_response_with_pulp_encoder(new_profile)
        redirect_response = generate_redirect_response(response, link['_href'])
        return redirect_response
Example #5
0
 def DELETE(self, consumer_id, content_type):
     """
     Delete an association between the specified
     consumer and profile.  Designed to be idempotent.
     @param consumer_id: A consumer ID.
     @type consumer_id: str
     @param content_type: The content type ID.
     @type content_type: str
     @return: The deleted model object:
         {consumer_id:<str>, content_type:<str>, profile:<dict>}
         Or, None if bind does not exist.
     @rtype: dict
     """
     manager = managers.consumer_profile_manager()
     resources = {
         dispatch_constants.RESOURCE_CONSUMER_TYPE:
             {consumer_id:dispatch_constants.RESOURCE_READ_OPERATION},
     }
     args = [
         consumer_id,
         content_type,
     ]
     tags = [
         resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
     ]
     call_request = CallRequest(manager.delete,
                                args=args,
                                resources=resources,
                                tags=tags)
     return self.ok(execution.execute(call_request))
Example #6
0
 def PUT(self, consumer_id, content_type):
     """
     Update the association of a profile with a consumer by content type ID.
     @param consumer_id: A consumer ID.
     @type consumer_id: str
     @param content_type: A content unit type ID.
     @type content_type: str
     @return: The updated model object:
         {consumer_id:<str>, content_type:<str>, profile:<dict>}
     @rtype: dict
     """
     body = self.params()
     profile = body.get('profile')
     resources = {
         dispatch_constants.RESOURCE_CONSUMER_TYPE:
             {consumer_id:dispatch_constants.RESOURCE_READ_OPERATION},
     }
     args = [
         consumer_id,
         content_type,
         profile,
     ]
     manager = managers.consumer_profile_manager()
     call_request = CallRequest(
         manager.update,
         args,
         resources=resources,
         weight=0)
     link = serialization.link.child_link_obj(consumer_id, content_type)
     result = execution.execute_sync_created(self, call_request, link)
     return result
Example #7
0
 def test_missing_consumer(self):
     # Test
     manager = factory.consumer_profile_manager()
     # self.CONSUMER_ID is not an existing consumer, as it is not built during setUp(), so this
     # should raise MissingResource
     self.assertRaises(MissingResource, manager.update, self.CONSUMER_ID, self.TYPE_1,
                       self.PROFILE_1)
 def test_delete_not_found(self):
     # Setup
     manager = factory.consumer_profile_manager()
     # Test
     path = '/v2/consumers/%s/profiles/unknown/' % self.CONSUMER_ID
     status, body = self.delete(path)
     self.assertEqual(status, 404)
Example #9
0
 def test_get_profiles_none(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     profiles = manager.get_profiles(self.CONSUMER_ID)
     self.assertEquals(len(profiles), 0)
Example #10
0
 def populate(self):
     manager = factory.consumer_manager()
     for id in self.CONSUMER_IDS:
         manager.register(id)
     manager = factory.consumer_profile_manager()
     for id in self.CONSUMER_IDS:
         manager.create(id, 'rpm', self.PROFILE)
Example #11
0
 def DELETE(self, consumer_id, content_type):
     """
     Delete an association between the specified
     consumer and profile.  Designed to be idempotent.
     @param consumer_id: A consumer ID.
     @type consumer_id: str
     @param content_type: The content type ID.
     @type content_type: str
     @return: The deleted model object:
         {consumer_id:<str>, content_type:<str>, profile:<dict>}
         Or, None if bind does not exist.
     @rtype: dict
     """
     manager = managers.consumer_profile_manager()
     args = [
         consumer_id,
         content_type,
     ]
     tags = [
         resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
                      consumer_id),
     ]
     call_request = CallRequest(manager.delete, args=args, tags=tags)
     call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
                                 consumer_id)
     return self.ok(execution.execute(call_request))
Example #12
0
 def test_get_profiles_none(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     profiles = manager.get_profiles(self.CONSUMER_ID)
     self.assertEquals(len(profiles), 0)
Example #13
0
    def PUT(self, consumer_id, content_type):
        """
        Update the association of a profile with a consumer by content type ID.
        @param consumer_id: A consumer ID.
        @type consumer_id: str
        @param content_type: A content unit type ID.
        @type content_type: str
        @return: The updated model object:
            {consumer_id:<str>, content_type:<str>, profile:<dict>}
        @rtype: dict
        """
        body = self.params()
        profile = body.get('profile')

        manager = managers.consumer_profile_manager()
        tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
                resource_tag(dispatch_constants.RESOURCE_CONTENT_UNIT_TYPE, content_type),
                action_tag('profile_update')]

        call_request = CallRequest(manager.update,
                                   [consumer_id, content_type],
                                   {'profile': profile},
                                   tags=tags,
                                   weight=0,
                                   kwarg_blacklist=['profile'])
        call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)

        call_report = CallReport.from_call_request(call_request)
        call_report.serialize_result = False

        consumer = execution.execute_sync(call_request, call_report)
        link = serialization.link.child_link_obj(consumer_id, content_type)
        consumer.update(link)

        return self.ok(consumer)
Example #14
0
    def post(self, request, consumer_id):
        """
        Associate a profile with a consumer by content type ID.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: A consumer ID.
        :type consumer_id: str

        :raises MissingValue: if some parameter were not provided

        :return: Response representing the created profile
        :rtype: django.http.HttpResponse
        """

        body = request.body_as_json
        content_type = body.get('content_type')
        profile = body.get('profile')

        manager = factory.consumer_profile_manager()
        new_profile = manager.create(consumer_id, content_type, profile)
        if content_type is None:
            raise MissingValue('content_type')
        link = add_link_profile(new_profile)
        response = generate_json_response_with_pulp_encoder(new_profile)
        redirect_response = generate_redirect_response(response, link['_href'])
        return redirect_response
Example #15
0
File: cud.py Project: stpierre/pulp
    def unregister(self, id):
        """
        Unregisters given consumer.

        @param id: identifies the consumer being unregistered
        @type  id: str

        @raises MissingResource: if the given consumer does not exist
        @raises OperationFailed: if any part of the unregister process fails;
                the exception will contain information on which sections failed
        @raises PulpExecutionException: if error during updating database collection
        """

        self.get_consumer(id)
        
        # Remove associate bind
        manager = factory.consumer_bind_manager()
        manager.consumer_deleted(id)
        
        # Remove associated profiles
        manager = factory.consumer_profile_manager()
        manager.consumer_deleted(id)

        # Notify agent
        agent_consumer = factory.consumer_agent_manager()
        agent_consumer.unregistered(id)

        # Database Updates
        try:
            Consumer.get_collection().remove({'id' : id}, safe=True)
        except Exception:
            _LOG.exception('Error updating database collection while removing consumer [%s]' % id)
            raise PulpExecutionException("database-error"), None, sys.exc_info()[2]

        factory.consumer_history_manager().record_event(id, 'consumer_unregistered')
Example #16
0
 def populate_profile(self, id, env):
     manager = managers.consumer_profile_manager()
     profile = []
     for i in range(0, env.profile_units):
         p = PROFILE_TEMPLATE.copy()
         p['name'] = 'unit_%d' % i
         profile.append(p)
     manager.create(id, self.TYPE_ID, profile)
Example #17
0
 def test_get_profile_not_found(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Verify
     self.assertRaises(MissingResource, manager.get_profile, self.CONSUMER_ID, self.TYPE_1)
Example #18
0
 def test_get_profile_not_found(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Verify
     self.assertRaises(MissingResource, manager.get_profile, self.CONSUMER_ID, self.TYPE_1)
Example #19
0
 def test_get_profile(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_1)
     self.assertTrue(profile is not None)
Example #20
0
 def test_get_profile(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_1)
     self.assertTrue(profile is not None)
Example #21
0
 def GET(self, consumer_id, content_type):
     """
     @param consumer_id: The consumer ID.
     @type consumer_id: str
     """
     manager = managers.consumer_profile_manager()
     profile = manager.get_profile(consumer_id, content_type)
     serialized = serialization.consumer.profile(profile)
     return self.ok(serialized)
Example #22
0
    def unregister(consumer_id):
        """
        Unregisters given consumer.

        :param  consumer_id:            identifies the consumer being unregistered
        :type   consumer_id:            str
        :raises MissingResource:        if the given consumer does not exist
        :raises OperationFailed:        if any part of the unregister process fails; the exception
                                        will contain information on which sections failed
        :raises PulpExecutionException: if error during updating database collection
        """

        ConsumerManager.get_consumer(consumer_id)

        # Remove associate bind
        manager = factory.consumer_bind_manager()
        manager.consumer_deleted(consumer_id)

        # Remove associated profiles
        manager = factory.consumer_profile_manager()
        manager.consumer_deleted(consumer_id)

        # Notify agent
        agent_consumer = factory.consumer_agent_manager()
        agent_consumer.unregistered(consumer_id)

        # remove from consumer groups
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        # delete any scheduled unit installs
        schedule_manager = factory.consumer_schedule_manager()
        for schedule in schedule_manager.get(consumer_id):
            # using "delete" on utils skips validation that the consumer exists.
            schedule_utils.delete(schedule.id)

        # Database Updates
        try:
            Consumer.get_collection().remove({'id': consumer_id}, safe=True)
        except Exception:
            _logger.exception(
                'Error updating database collection while removing consumer [%s]'
                % consumer_id)
            raise PulpExecutionException(
                "database-error"), None, sys.exc_info()[2]

        # remove the consumer from any groups it was a member of
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        factory.consumer_history_manager().record_event(
            consumer_id, 'consumer_unregistered')
Example #23
0
 def GET(self, consumer_id):
     """
     Get all profiles associated with a consumer.
     @param consumer_id: The consumer ID.
     @type consumer_id: str
     @return: A list of profiles:
       profile is: {consumer_id:<str>, content_type:<str>, profile:<dict>}
     @return: list
     """
     manager = managers.consumer_profile_manager()
     profiles = manager.get_profiles(consumer_id)
     profiles = [serialization.consumer.profile(p) for p in profiles]
     return self.ok(profiles)
Example #24
0
 def test_get_by_type(self):
     # Setup
     self.populate()
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Test
     path = '/v2/consumers/%s/profiles/%s/' % (self.CONSUMER_ID, self.TYPE_1)
     status, body = self.get(path)
     self.assertEqual(status, 200)
     self.assertEqual(body['consumer_id'], self.CONSUMER_ID)
     self.assertEqual(body['content_type'], self.TYPE_1)
     self.assertEqual(body['profile'], self.PROFILE_1)
Example #25
0
 def GET(self, consumer_id):
     """
     Get all profiles associated with a consumer.
     @param consumer_id: The consumer ID.
     @type consumer_id: str
     @return: A list of profiles:
       profile is: {consumer_id:<str>, content_type:<str>, profile:<dict>}
     @return: list
     """
     manager = managers.consumer_profile_manager()
     profiles = manager.get_profiles(consumer_id)
     profiles = [serialization.consumer.profile(p) for p in profiles]
     return self.ok(profiles)
 def test_create(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     # Verify
     collection = UnitProfile.get_collection()
     cursor = collection.find({"consumer_id": self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 1)
     self.assertEquals(profiles[0]["consumer_id"], self.CONSUMER_ID)
     self.assertEquals(profiles[0]["content_type"], self.TYPE_1)
     self.assertEquals(profiles[0]["profile"], self.PROFILE_1)
Example #27
0
File: cud.py Project: bartwo/pulp
    def unregister(self, consumer_id):
        """
        Unregisters given consumer.

        @param consumer_id: identifies the consumer being unregistered
        @type  consumer_id: str

        @raises MissingResource: if the given consumer does not exist
        @raises OperationFailed: if any part of the unregister process fails;
                the exception will contain information on which sections failed
        @raises PulpExecutionException: if error during updating database collection
        """

        self.get_consumer(consumer_id)

        # Remove associate bind
        manager = factory.consumer_bind_manager()
        manager.consumer_deleted(consumer_id)

        # Remove associated profiles
        manager = factory.consumer_profile_manager()
        manager.consumer_deleted(consumer_id)

        # Notify agent
        agent_consumer = factory.consumer_agent_manager()
        agent_consumer.unregistered(consumer_id)

        # remove from consumer groups
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        # delete any scheduled unit installs
        schedule_manager = factory.schedule_manager()
        schedule_manager.delete_all_unit_install_schedules(consumer_id)
        schedule_manager.delete_all_unit_update_schedules(consumer_id)
        schedule_manager.delete_all_unit_uninstall_schedules(consumer_id)

        # Database Updates
        try:
            Consumer.get_collection().remove({'id' : consumer_id}, safe=True)
        except Exception:
            _LOG.exception('Error updating database collection while removing '
                'consumer [%s]' % consumer_id)
            raise PulpExecutionException("database-error"), None, sys.exc_info()[2]

        # remove the consumer from any groups it was a member of
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        factory.consumer_history_manager().record_event(consumer_id, 'consumer_unregistered')
 def test_fetch_by_type2(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Test
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_2)
     # Verify
     self.assertTrue(profile is not None)
     self.assertEquals(profile["consumer_id"], self.CONSUMER_ID)
     self.assertEquals(profile["content_type"], self.TYPE_2)
     self.assertEquals(profile["profile"], self.PROFILE_2)
Example #29
0
 def test_fetch_by_type2(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Test
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_2)
     # Verify
     self.assertTrue(profile is not None)
     self.assertEquals(profile['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profile['content_type'], self.TYPE_2)
     self.assertEquals(profile['profile'], self.PROFILE_2)
Example #30
0
 def test_create(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     # Verify
     collection = UnitProfile.get_collection()
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 1)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_1)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_1)
Example #31
0
    def unregister(consumer_id):
        """
        Unregisters given consumer.

        :param  consumer_id:            identifies the consumer being unregistered
        :type   consumer_id:            str
        :raises MissingResource:        if the given consumer does not exist
        :raises OperationFailed:        if any part of the unregister process fails; the exception
                                        will contain information on which sections failed
        :raises PulpExecutionException: if error during updating database collection
        """

        ConsumerManager.get_consumer(consumer_id)

        # Remove associate bind
        manager = factory.consumer_bind_manager()
        manager.consumer_deleted(consumer_id)

        # Remove associated profiles
        manager = factory.consumer_profile_manager()
        manager.consumer_deleted(consumer_id)

        # Notify agent
        agent_consumer = factory.consumer_agent_manager()
        agent_consumer.unregister(consumer_id)

        # remove from consumer groups
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        # delete any scheduled unit installs
        schedule_manager = factory.consumer_schedule_manager()
        for schedule in schedule_manager.get(consumer_id):
            # using "delete" on utils skips validation that the consumer exists.
            schedule_utils.delete(schedule.id)

        # Database Updates
        try:
            Consumer.get_collection().remove({'id': consumer_id})
        except Exception:
            _logger.exception(
                'Error updating database collection while removing consumer [%s]' % consumer_id)
            raise PulpExecutionException("database-error"), None, sys.exc_info()[2]

        # remove the consumer from any groups it was a member of
        group_manager = factory.consumer_group_manager()
        group_manager.remove_consumer_from_groups(consumer_id)

        factory.consumer_history_manager().record_event(consumer_id, 'consumer_unregistered')
Example #32
0
 def test_fetch_by_type2(self):
     # Setup
     self.populate()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Test
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_2)
     # Verify
     self.assertTrue(profile is not None)
     self.assertEquals(profile['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profile['content_type'], self.TYPE_2)
     self.assertEquals(profile['profile'], self.PROFILE_2)
     expected_hash = UnitProfile.calculate_hash(self.PROFILE_2)
     self.assertEqual(profile['profile_hash'], expected_hash)
Example #33
0
 def test_fetch_by_type1(self):
     # Setup
     self.populate()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Test
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_1)
     # Verify
     self.assertTrue(profile is not None)
     self.assertEquals(profile['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profile['content_type'], self.TYPE_1)
     self.assertEquals(profile['profile'], self.PROFILE_1)
     expected_hash = UnitProfile.calculate_hash(self.PROFILE_1)
     self.assertEqual(profile['profile_hash'], expected_hash)
Example #34
0
 def __profiled_consumer(self, consumer_id):
     """
     Get a profiler consumer model object.
     :param id: A consumer ID.
     :type id: str
     :return: A populated profiler consumer model object.
     :rtype: L{ProfiledConsumer}
     """
     profiles = {}
     manager = managers.consumer_profile_manager()
     for p in manager.get_profiles(consumer_id):
         typeid = p['content_type']
         profile = p['profile']
         profiles[typeid] = profile
     return ProfiledConsumer(consumer_id, profiles)
Example #35
0
 def test_delete(self):
     # Setup
     self.populate()
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     profiles = manager.get_profiles(self.CONSUMER_ID)
     self.assertEquals(len(profiles), 2)
     # Test
     path = '/v2/consumers/%s/profiles/%s/' % (self.CONSUMER_ID, self.TYPE_1)
     status, body = self.delete(path)
     profiles = manager.get_profiles(self.CONSUMER_ID)
     self.assertEquals(len(profiles), 1)
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_2)
     self.assertTrue(profile is not None)
Example #36
0
 def DELETE(self, consumer_id, content_type):
     """
     Delete an association between the specified
     consumer and profile.  Designed to be idempotent.
     @param consumer_id: A consumer ID.
     @type consumer_id: str
     @param content_type: The content type ID.
     @type content_type: str
     @return: The deleted model object:
         {consumer_id:<str>, content_type:<str>, profile:<dict>}
         Or, None if bind does not exist.
     @rtype: dict
     """
     manager = managers.consumer_profile_manager()
     return self.ok(manager.delete(consumer_id, content_type))
Example #37
0
 def __profiled_consumer(self, consumer_id):
     """
     Get a profiler consumer model object.
     @param id: A consumer ID.
     @type id: str
     @return: A populated profiler consumer model object.
     @rtype: L{ProfiledConsumer}
     """
     profiles = {}
     manager = managers.consumer_profile_manager()
     for p in manager.get_profiles(consumer_id):
         typeid = p['content_type']
         profile = p['profile']
         profiles[typeid] = profile
     return ProfiledConsumer(consumer_id, profiles)
Example #38
0
 def test_consumer_deleted(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     collection = UnitProfile.get_collection()
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 2)
     # Test
     manager.consumer_deleted(self.CONSUMER_ID)
     cursor = collection.find()
     profiles = list(cursor)
     self.assertEquals(len(profiles), 0)
 def test_consumer_deleted(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     collection = UnitProfile.get_collection()
     cursor = collection.find({"consumer_id": self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 2)
     # Test
     manager.consumer_deleted(self.CONSUMER_ID)
     cursor = collection.find()
     profiles = list(cursor)
     self.assertEquals(len(profiles), 0)
Example #40
0
    def GET(self, consumer_id):
        """
        Get all profiles associated with a consumer.
        @param consumer_id: The consumer ID.
        @type consumer_id: str
        @return: A list of profiles:
          profile is: {consumer_id:<str>, content_type:<str>, profile:<dict>}
        @return: list
        """
        # Check that the consumer exists and raise a MissingResource exception, in case it doesn't.
        managers.consumer_manager().get_consumer(consumer_id)

        manager = managers.consumer_profile_manager()
        profiles = manager.get_profiles(consumer_id)
        profiles = [serialization.consumer.profile(p) for p in profiles]
        return self.ok(profiles)
Example #41
0
 def test_create(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     # Verify
     collection = UnitProfile.get_collection()
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 1)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_1)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_1)
     expected_hash = UnitProfile.calculate_hash(self.PROFILE_1)
     self.assertEqual(profiles[0]['profile_hash'], expected_hash)
Example #42
0
    def _profiled_consumer(consumer_id):
        """
        Get a profiler consumer model object.

        :param consumer_id: A consumer ID.
        :type  consumer_id: str
        :return: A populated profiler consumer model object.
        :rtype:  pulp.plugins.model.Consumer
        """
        profiles = {}
        manager = managers.consumer_profile_manager()
        for p in manager.get_profiles(consumer_id):
            typeid = p['content_type']
            profile = p['profile']
            profiles[typeid] = profile
        return ProfiledConsumer(consumer_id, profiles)
Example #43
0
 def test_post(self):
     # Setup
     self.populate()
     # Test
     path = '/v2/consumers/%s/profiles/' % self.CONSUMER_ID
     body = dict(content_type=self.TYPE_1, profile=self.PROFILE_1)
     status, body = self.post(path, body)
     # Verify
     self.assertEqual(status, 201)
     self.assertEqual(body['consumer_id'], self.CONSUMER_ID)
     self.assertEqual(body['content_type'], self.TYPE_1)
     self.assertEqual(body['profile'], self.PROFILE_1)
     manager = factory.consumer_profile_manager()
     profile = manager.get_profile(self.CONSUMER_ID, self.TYPE_1)
     for key in ('consumer_id', 'content_type', 'profile'):
         self.assertEqual(body[key], profile[key])
Example #44
0
    def _get_consumer_profile_map(consumer_ids):
        """
        Create a consumer-profile map:
        {consumer id:
            {'profiles': list of tuples with profile details,
             'all_profiles_hash': hash of all consumer's profile_hashes}}

        :param consumer_ids: consumers for which applicability needs to be regenerated
        :type  consumer_ids: list

        :return: consumer-profile map described above
        :rtype: dict
        """
        consumer_profile_manager = managers.consumer_profile_manager()
        consumer_ids = list(set(consumer_ids))

        # Get all unit profiles associated with given consumers
        unit_profile_criteria = Criteria(
            filters={'consumer_id': {
                '$in': consumer_ids
            }},
            fields=['consumer_id', 'profile_hash', 'content_type', 'id'])
        all_unit_profiles = consumer_profile_manager.find_by_criteria(
            unit_profile_criteria)

        consumer_profiles_map = {}

        for unit_profile in all_unit_profiles:
            profile_hash = unit_profile['profile_hash']
            content_type = unit_profile['content_type']
            consumer_id = unit_profile['consumer_id']
            profile_id = unit_profile['id']

            profile_tuple = (profile_hash, content_type, profile_id)
            # Add this tuple to the list of profile tuples for a consumer
            consumer_profiles_map.setdefault(consumer_id, {})
            consumer_profiles_map[consumer_id].setdefault(
                'profiles', []).append(profile_tuple)

        # Calculate and add all_profiles_hash to the map
        for consumer_id, pdata in consumer_profiles_map.items():
            profile_hashes = [pr_hash for pr_hash, _, _ in pdata['profiles']]
            all_profiles_hash = _calculate_all_profiles_hash(profile_hashes)
            consumer_profiles_map[consumer_id][
                'all_profiles_hash'] = all_profiles_hash

        return consumer_profiles_map
Example #45
0
 def test_update_with_consumer_history(self):
     # Setup
     self.populate()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     # Test
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_2)
     # Verify
     collection = ConsumerHistoryEvent.get_collection()
     history = collection.find_one({'consumer_id': self.CONSUMER_ID,
                                    'type': 'unit_profile_changed',
                                    'details': {'profile_content_type': self.TYPE_1}})
     self.assertTrue(history is not None)
     self.assertEqual(history['consumer_id'], self.CONSUMER_ID)
     self.assertEqual(history['type'], 'unit_profile_changed')
     self.assertEqual(history['originator'], 'SYSTEM')
     self.assertEqual(history['details'], {'profile_content_type': self.TYPE_1})
Example #46
0
 def test_get_profiles(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     profiles = manager.get_profiles(self.CONSUMER_ID)
     # Verify
     profiles = sorted(profiles)
     self.assertEquals(len(profiles), 2)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_1)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_1)
     self.assertEquals(profiles[1]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[1]['content_type'], self.TYPE_2)
     self.assertEquals(profiles[1]['profile'], self.PROFILE_2)
Example #47
0
 def test_get_profiles(self):
     # Setup
     self.populate()
     # Test
     manager = factory.consumer_profile_manager()
     manager.create(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.create(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     profiles = manager.get_profiles(self.CONSUMER_ID)
     # Verify
     profiles = sorted(profiles)
     self.assertEquals(len(profiles), 2)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_1)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_1)
     self.assertEquals(profiles[1]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[1]['content_type'], self.TYPE_2)
     self.assertEquals(profiles[1]['profile'], self.PROFILE_2)
Example #48
0
    def POST(self, consumer_id):
        """
        Associate a profile with a consumer by content type ID.
        @param consumer_id: A consumer ID.
        @type consumer_id: str
        @return: The created model object:
            {consumer_id:<str>, content_type:<str>, profile:<dict>}
        @rtype: dict
        """
        body = self.params()
        content_type = body.get('content_type')
        profile = body.get('profile')

        manager = managers.consumer_profile_manager()
        new_profile = manager.create(consumer_id, content_type, profile)
        link = serialization.link.child_link_obj(consumer_id, content_type)
        new_profile.update(link)
        return self.created(link['_href'], new_profile)
Example #49
0
    def delete(self, request, consumer_id, content_type):
        """
        Delete an association between the specified
        consumer and profile.  Designed to be idempotent.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: A consumer ID.
        :type consumer_id: str
        :param content_type: The content type ID.
        :type content_type: str

        :return: An empty response
        :rtype: django.http.HttpResponse
        """

        manager = factory.consumer_profile_manager()
        response = manager.delete(consumer_id, content_type)
        return generate_json_response(response)
Example #50
0
    def get(self, request, consumer_id, content_type):
        """
        Get profile by content type associated with consumer.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: The consumer ID.
        :type consumer_id: str
        :param content_type: The content type
        :type consumer_id: str

        :return: Response representing consumer's profile
        :rtype: django.http.HttpResponse
        """

        manager = factory.consumer_profile_manager()
        profile = manager.get_profile(consumer_id, content_type)
        add_link_profile(profile)
        return generate_json_response_with_pulp_encoder(profile)
Example #51
0
 def test_multiple_types(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     # Test
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     # Verify
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     cursor.sort('content_type', pymongo.ASCENDING)
     profiles = list(cursor)
     # Type_1
     self.assertEquals(len(profiles), 2)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_1)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_1)
     self.assertEquals(profiles[1]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[1]['content_type'], self.TYPE_2)
     self.assertEquals(profiles[1]['profile'], self.PROFILE_2)
Example #52
0
 def populate(self, bindings=False, profiles=False):
     if bindings:
         manager = factory.repo_manager()
         manager.create_repo(self.REPO_ID)
         manager = factory.repo_distributor_manager()
         manager.add_distributor(self.REPO_ID,
                                 self.DISTRIBUTOR_TYPE_ID, {},
                                 True,
                                 distributor_id=self.DISTRIBUTOR_ID)
     for consumer_id in self.CONSUMER_IDS:
         manager = factory.consumer_manager()
         manager.register(consumer_id)
         if bindings:
             manager = factory.consumer_bind_manager()
             manager.bind(consumer_id, self.REPO_ID, self.DISTRIBUTOR_ID,
                          self.NOTIFY_AGENT, self.BINDING_CONFIG)
     if profiles:
         manager = factory.consumer_profile_manager()
         for consumer_id in self.CONSUMER_IDS:
             manager.create(consumer_id, 'rpm', self.PROFILE)
Example #53
0
    def get(self, request, consumer_id):
        """
        Get all profiles associated with a consumer.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: A consumer ID.
        :type consumer_id: str

        :return: Response representing list of profiles
        :rtype: django.http.HttpResponse
        """

        # Check that the consumer exists and raise a MissingResource exception, in case it doesn't.
        factory.consumer_manager().get_consumer(consumer_id)

        manager = factory.consumer_profile_manager()
        profiles = manager.get_profiles(consumer_id)
        for consumer_profile in profiles:
            add_link_profile(consumer_profile)
        return generate_json_response_with_pulp_encoder(profiles)
Example #54
0
    def PUT(self, consumer_id, content_type):
        """
        Update the association of a profile with a consumer by content type ID.
        @param consumer_id: A consumer ID.
        @type consumer_id: str
        @param content_type: A content unit type ID.
        @type content_type: str
        @return: The updated model object:
            {consumer_id:<str>, content_type:<str>, profile:<dict>}
        @rtype: dict
        """
        body = self.params()
        profile = body.get('profile')

        manager = managers.consumer_profile_manager()
        consumer = manager.update(consumer_id, content_type, profile)

        link = serialization.link.child_link_obj(consumer_id, content_type)
        consumer.update(link)

        return self.ok(consumer)
Example #55
0
 def test_delete(self):
     # Setup
     self.populate()
     collection = UnitProfile.get_collection()
     manager = factory.consumer_profile_manager()
     manager.update(self.CONSUMER_ID, self.TYPE_1, self.PROFILE_1)
     manager.update(self.CONSUMER_ID, self.TYPE_2, self.PROFILE_2)
     collection = UnitProfile.get_collection()
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 2)
     # Test
     manager.delete(self.CONSUMER_ID, self.TYPE_1)
     # Verify
     collection = UnitProfile.get_collection()
     cursor = collection.find({'consumer_id': self.CONSUMER_ID})
     profiles = list(cursor)
     self.assertEquals(len(profiles), 1)
     self.assertEquals(profiles[0]['consumer_id'], self.CONSUMER_ID)
     self.assertEquals(profiles[0]['content_type'], self.TYPE_2)
     self.assertEquals(profiles[0]['profile'], self.PROFILE_2)
     expected_hash = UnitProfile.calculate_hash(self.PROFILE_2)
     self.assertEqual(profiles[0]['profile_hash'], expected_hash)
Example #56
0
    def put(self, request, consumer_id, content_type):
        """
        Update the association of a profile with a consumer by content type ID.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param consumer_id: A consumer ID.
        :type consumer_id: str
        :param content_type: A content unit type ID.
        :type content_type: str

        :return: Response representing the updated profile
        :rtype: django.http.HttpResponse
        """

        body = request.body_as_json
        profile = body.get('profile')

        manager = factory.consumer_profile_manager()
        consumer = manager.update(consumer_id, content_type, profile)

        add_link_profile(consumer)

        return generate_json_response_with_pulp_encoder(consumer)