def test_send(self, mock_gofer_agent):
context = Mock()
context.agent_id = "123"
context.url = "http://broker.com"
context.transport = "qpid"
context.authenticator = Mock()
task_id = "5678"
criteria = {"match": {"task_id": task_id}}
mock_agent = Mock()
mock_gofer_agent.return_value = mock_agent
mock_admin = Mock()
mock_agent.Admin = Mock(return_value=mock_admin)
agent = PulpAgent()
agent.cancel(context, task_id)
mock_gofer_agent.assert_called_with(
context.agent_id,
url=context.url,
transport=context.transport,
authenticator=context.authenticator,
async=True,
)
mock_admin.cancel.assert_called_with(criteria=criteria)
def test_send(self, mock_gofer_agent):
context = Mock()
context.agent_id = '123'
context.url = 'http://broker.com'
context.transport = 'qpid'
context.authenticator = Mock()
task_id = '5678'
criteria = {'match': {'task_id': task_id}}
mock_agent = Mock()
mock_gofer_agent.return_value = mock_agent
mock_admin = Mock()
mock_agent.Admin = Mock(return_value=mock_admin)
agent = PulpAgent()
agent.cancel(context, task_id)
mock_gofer_agent.assert_called_with(
context.agent_id,
url=context.url,
transport=context.transport,
authenticator=context.authenticator,
async=True)
mock_admin.cancel.assert_called_with(criteria=criteria)
def test_cancel(self):
# Test
task_id = '123'
agent = DirectAgent(CONSUMER)
agent.cancel(task_id)
# Verify
criteria = {'eq': task_id}
mock_agent.Admin.cancel.assert_called_once_with(criteria=criteria)
def test_cancel(self):
# Test
task_id = '123'
agent = DirectAgent(CONSUMER)
agent.cancel(task_id)
# Verify
criteria = {'eq': task_id}
mock_agent.Admin.cancel.assert_called_once_with(criteria=criteria)
def test_delete_queue(self, queue, add_connector):
url = 'test-url'
name = 'test-queue'
# test
agent = PulpAgent()
agent.delete_queue(url, name)
# validation
add_connector.assert_called_once_with()
queue.assert_called_once_with(name, url)
queue.return_value.purge.assert_called_once_with()
queue.return_value.delete.assert_called_once_with()
def cancel_request(self, consumer_id, task_id):
"""
Cancel an agent request associated with the specified task ID.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param: task_id: The task ID associated with the request.
:type: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
context = Context(consumer)
agent = PulpAgent()
agent.cancel(context, task_id)
def cancel_request(self, consumer_id, task_id):
"""
Cancel an agent request associated with the specified task ID.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param: task_id: The task ID associated with the request.
:type: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
context = Context(consumer)
agent = PulpAgent()
agent.cancel(context, task_id)
def test_delete_queue(self, queue, add_connector):
url = 'test-url'
name = 'test-queue'
# test
agent = PulpAgent()
agent.delete_queue(url, name)
# validation
add_connector.assert_called_once_with()
queue.assert_called_once_with(name, url)
queue.return_value.purge.assert_called_once_with()
queue.return_value.delete.assert_called_once_with()
def test_delete_queue_not_found(self, queue, add_connector):
url = 'test-url'
name = 'test-queue'
queue.return_value.purge.side_effect = NotFound
# test
agent = PulpAgent()
agent.delete_queue(url, name)
# validation
add_connector.assert_called_once_with()
queue.assert_called_once_with(name, url)
queue.return_value.purge.assert_called_once_with()
self.assertFalse(queue.delete.called)
def test_delete_queue_not_found(self, queue, add_connector):
url = 'test-url'
name = 'test-queue'
queue.return_value.purge.side_effect = NotFound
# test
agent = PulpAgent()
agent.delete_queue(url, name)
# validation
add_connector.assert_called_once_with()
queue.assert_called_once_with(name, url)
queue.return_value.purge.assert_called_once_with()
self.assertFalse(queue.delete.called)
def uninstall(self, id, units, options={}):
"""
Uninstall content on a consumer.
@param id: A consumer id.
@type id: str
@param units: A list of content units to be uninstalled.
@type units: list of:
{ type_id:<str>, unit_key:<dict> }
@param options: Uninstall options; based on unit type.
@type options: dict
"""
collection = Consumer.get_collection()
consumer = collection.find_one({'id': id})
if consumer is None:
raise MissingResource(id)
agent = PulpAgent(consumer)
agent.uninstall_units(units, options)
def delete_queue(url, name, consumer_id):
"""
Delete the agent queue.
:param url: The broker URL.
:type url: str
:param name: The queue name.
:type name: str
:param consumer_id: The consumer ID.
:type consumer_id: str
"""
try:
manager = managers.consumer_manager()
manager.get_consumer(consumer_id)
return # still registered (abort)
except MissingResource:
# expected
pass
agent = PulpAgent()
agent.delete_queue(url, name)
def delete_queue(url, name, consumer_id):
"""
Delete the agent queue.
:param url: The broker URL.
:type url: str
:param name: The queue name.
:type name: str
:param consumer_id: The consumer ID.
:type consumer_id: str
"""
try:
manager = managers.consumer_manager()
manager.get_consumer(consumer_id)
return # still registered (abort)
except MissingResource:
# expected
pass
agent = PulpAgent()
agent.delete_queue(url, name)
def test_cancel(self, _agent):
context = Context()
task_id = '5678'
# test
agent = PulpAgent()
agent.cancel(context, task_id)
# validation
context.__enter__.assert_called_once_with()
self.assertTrue(context.__exit__.called)
_agent.assert_called_with(
context.url,
context.address,
authenticator=context.authenticator,
wait=0)
_agent.return_value.Admin.return_value.cancel.assert_called_with(
criteria={'match': {'task_id': task_id}})
def test_cancel(self, _agent):
context = Context()
task_id = '5678'
# test
agent = PulpAgent()
agent.cancel(context, task_id)
# validation
context.__enter__.assert_called_once_with()
self.assertTrue(context.__exit__.called)
_agent.assert_called_with(context.url,
context.address,
authenticator=context.authenticator,
wait=0)
_agent.return_value.Admin.return_value.cancel.assert_called_with(
criteria={'match': {
'task_id': task_id
}})
def bind(consumer_id, repo_id, distributor_id, options):
"""
Request the agent to perform the specified bind. This method will be called
after the server-side representation of the binding has been created.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param repo_id: A repository ID.
:type repo_id: str
:param distributor_id: A distributor ID.
:type distributor_id: str
:param options: The options are handler specific.
:type options: dict
:return: The task created by the bind
:rtype: dict
"""
# track agent operations using a pseudo task
task_id = str(uuid4())
task_tags = [
tags.resource_tag(tags.RESOURCE_CONSUMER_TYPE, consumer_id),
tags.resource_tag(tags.RESOURCE_REPOSITORY_TYPE, repo_id),
tags.resource_tag(tags.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
tags.action_tag(tags.ACTION_AGENT_BIND)
]
task = TaskStatus(task_id, 'agent', tags=task_tags).save()
# agent request
consumer_manager = managers.consumer_manager()
binding_manager = managers.consumer_bind_manager()
consumer = consumer_manager.get_consumer(consumer_id)
binding = binding_manager.get_bind(consumer_id, repo_id, distributor_id)
agent_bindings = AgentManager._bindings([binding])
context = Context(
consumer,
task_id=task_id,
action='bind',
consumer_id=consumer_id,
repo_id=repo_id,
distributor_id=distributor_id)
agent = PulpAgent()
agent.consumer.bind(context, agent_bindings, options)
# bind action tracking
consumer_manager = managers.consumer_bind_manager()
consumer_manager.action_pending(
consumer_id,
repo_id,
distributor_id,
Bind.Action.BIND,
task_id)
return task
def unregistered(self, consumer_id):
"""
Notification that a consumer (agent) has
been unregistered. This ensure that all registration
artifacts have been cleaned up.
:param consumer_id: The consumer ID.
:type consumer_id: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
context = Context(consumer)
agent = PulpAgent()
agent.consumer.unregistered(context)
def unbind(consumer_id, repo_id, distributor_id, options):
"""
Request the agent to perform the specified unbind.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param repo_id: A repository ID.
:type repo_id: str
:param distributor_id: A distributor ID.
:type distributor_id: str
:param options: The options are handler specific.
:type options: dict
:return: A task ID that may be used to track the agent request.
:rtype: str
"""
# track agent operations using a pseudo task
task_id = str(uuid4())
task_tags = [
tags.resource_tag(tags.RESOURCE_CONSUMER_TYPE, consumer_id),
tags.resource_tag(tags.RESOURCE_REPOSITORY_TYPE, repo_id),
tags.resource_tag(tags.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
tags.action_tag(tags.ACTION_AGENT_UNBIND)
]
task = TaskStatus(task_id, 'agent', tags=task_tags).save()
# agent request
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
binding = dict(repo_id=repo_id, distributor_id=distributor_id)
bindings = AgentManager._unbindings([binding])
context = Context(
consumer,
task_id=task_id,
action='unbind',
consumer_id=consumer_id,
repo_id=repo_id,
distributor_id=distributor_id)
agent = PulpAgent()
agent.consumer.unbind(context, bindings, options)
# unbind action tracking
manager = managers.consumer_bind_manager()
manager.action_pending(
consumer_id,
repo_id,
distributor_id,
Bind.Action.UNBIND,
task_id)
return task
def test_send(self, mock_gofer_agent):
context = Mock()
context.route = '123'
context.url = 'http://broker.com'
context.authenticator = Mock()
task_id = '5678'
criteria = {'match': {'task_id': task_id}}
mock_agent = Mock()
mock_gofer_agent.return_value = mock_agent
mock_admin = Mock()
mock_agent.Admin = Mock(return_value=mock_admin)
agent = PulpAgent()
agent.cancel(context, task_id)
mock_gofer_agent.assert_called_with(
context.url,
context.route,
authenticator=context.authenticator,
wait=0)
mock_admin.cancel.assert_called_with(criteria=criteria)
def test_status(self):
# Setup
listener = HeartbeatListener('queue')
envelope = Envelope(heartbeat=dict(uuid='A', next=10))
listener.dispatch(envelope)
# Test
result = DirectAgent.status(['A','B'])
# Verify
self.assertEqual(len(result), 2)
# A
alive, next_heartbeat, details = result['A']
self.assertTrue(alive)
self.assertTrue(isinstance(next_heartbeat, basestring))
self.assertTrue(isinstance(details, dict))
# B
alive, last_heartbeat, details = result['B']
self.assertFalse(alive)
self.assertTrue(last_heartbeat is None)
self.assertTrue(isinstance(details, dict))
def test_status(self):
# Setup
listener = HeartbeatListener('queue')
envelope = Envelope(heartbeat=dict(uuid='A', next=10))
listener.dispatch(envelope)
# Test
result = DirectAgent.status(['A', 'B'])
# Verify
self.assertEqual(len(result), 2)
# A
alive, next_heartbeat, details = result['A']
self.assertTrue(alive)
self.assertTrue(isinstance(next_heartbeat, basestring))
self.assertTrue(isinstance(details, dict))
# B
alive, last_heartbeat, details = result['B']
self.assertFalse(alive)
self.assertTrue(last_heartbeat is None)
self.assertTrue(isinstance(details, dict))
def uninstall_content(consumer_id, units, options):
"""
Uninstall content units on a consumer.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param units: A list of content units to be uninstalled.
:type units: list of:
{ type_id:<str>, type_id:<dict> }
:param options: Uninstall options; based on unit type.
:type options: dict
:return: A task ID that may be used to track the agent request.
:rtype: dict
"""
# track agent operations using a pseudo task
task_id = str(uuid4())
task_tags = [
tags.resource_tag(tags.RESOURCE_CONSUMER_TYPE, consumer_id),
tags.action_tag(tags.ACTION_AGENT_UNIT_UNINSTALL)
]
task = TaskStatus(task_id, 'agent', tags=task_tags).save()
# agent request
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
conduit = ProfilerConduit()
collated = Units(units)
for typeid, units in collated.items():
pc = AgentManager._profiled_consumer(consumer_id)
profiler, cfg = AgentManager._profiler(typeid)
units = AgentManager._invoke_plugin(
profiler.uninstall_units,
pc,
units,
options,
cfg,
conduit)
collated[typeid] = units
units = collated.join()
context = Context(consumer, task_id=task_id, consumer_id=consumer_id)
agent = PulpAgent()
agent.content.uninstall(context, units, options)
return task
def unregister(consumer_id):
"""
Notification that a consumer (agent) has
been unregistered. This ensure that all registration
artifacts have been cleaned up. Then, we fire off a task to lazily
delete the agent queue.
:param consumer_id: The consumer ID.
:type consumer_id: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
context = Context(consumer)
agent = PulpAgent()
agent.consumer.unregister(context)
url = context.url
name = context.address.split('/')[-1]
task_tags = [
tags.resource_tag(tags.ACTION_AGENT_QUEUE_DELETE, consumer_id)
]
delete_queue.apply_async(args=[url, name, consumer_id],
countdown=QUEUE_DELETE_DELAY,
tags=task_tags)
def test_capabilities(self):
agent = PulpAgent()
self.assertEqual(agent.consumer, Consumer)
self.assertEqual(agent.content, Content)
self.assertEqual(agent.profile, Profile)
