def test_max_instances(self, plugin):
system = System(
name="name",
version="1.0.0",
instances=[Instance(name="1"),
Instance(name="2")],
)
new_system = plugin._setup_system(system, {})
assert new_system.max_instances == 2
def test_max_instances(self, plugin, client):
system = System(
name="name",
version="1.0.0",
instances=[Instance(name="1"),
Instance(name="2")],
)
new_system = plugin._setup_system(client, "default", system, "", "",
"", "", {}, None, None)
assert new_system.max_instances == 2
def default_system(self, command1):
return System(
name="foo",
version="1.0.0",
instances=[Instance(name="foo")],
commands=[command1],
)
def _setup_system(self, client, inst_name, system, name, description, version, icon_name,
metadata, display_name, max_instances):
if system:
if name or description or version or icon_name or display_name or max_instances:
raise ValidationError("Sorry, you can't specify a system as well as system "
"creation helper keywords (name, description, version, "
"max_instances, display_name, and icon_name)")
if not system.instances:
raise ValidationError("Explicit system definition requires explicit instance "
"definition (use instances=[Instance(name='default')] "
"for default behavior)")
if not system.max_instances:
system.max_instances = len(system.instances)
else:
name = name or os.environ.get('BG_NAME', None)
version = version or os.environ.get('BG_VERSION', None)
if client.__doc__ and not description:
description = self.client.__doc__.split("\n")[0]
system = System(name=name, description=description, version=version,
icon_name=icon_name, commands=client._commands,
max_instances=max_instances or 1,
instances=[Instance(name=inst_name)],
metadata=metadata, display_name=display_name)
return system
def test_existing_multiple(self, tmp_path, loader, registry, plugin_1, bg_instance):
"""This is mainly to test that Instance IDs are correct
We save a system with 2 instances:
- instance1, 58542eb571afd47ead90beef
- instance2, 58542eb571afd47ead90beee
Then we load a plugin that defines instances [instance2, instance3].
Correct behavior is:
- instance1 removed from the database
- instance3 created in the database
- instance2 remains in the database, and the ID remains the same
"""
instance1 = Instance(name="instance1", id="58542eb571afd47ead90beef")
instance2 = Instance(name="instance2", id="58542eb571afd47ead90beee")
create_system(
System(name="foo", version="1.0", instances=[instance1, instance2])
)
plugin = tmp_path / "plugin"
plugin.mkdir()
write_file(
plugin,
textwrap.dedent(
"""
NAME='foo'
VERSION='1.0'
PLUGIN_ENTRY='entry.py'
INSTANCES=["instance2", "instance3"]
"""
),
)
plugin_runners = loader.load_plugin(plugin)
assert len(plugin_runners) == 2
assert db.query_unique(Instance, name="instance1") is None
assert db.query_unique(Instance, name="instance3") is not None
instance2_db = db.query_unique(Instance, name="instance2")
assert instance2_db is not None
assert instance2_db.id == instance2.id
def _initialize(self):
self.logger.debug("Initializing plugin %s", self.unique_name)
# TODO: We should use self.bm_client.upsert_system once it is supported
existing_system = self.bm_client.find_unique_system(
name=self.system.name, version=self.system.version)
if existing_system:
if existing_system.has_different_commands(self.system.commands):
new_commands = self.system.commands
else:
new_commands = None
if not existing_system.has_instance(self.instance_name):
if len(existing_system.instances) < existing_system.max_instances:
existing_system.instances.append(Instance(name=self.instance_name))
self.bm_client.create_system(existing_system)
else:
raise PluginValidationError('Unable to create plugin with instance name "%s": '
'System "%s[%s]" has an instance limit of %d and '
'existing instances %s' %
(self.instance_name, existing_system.name,
existing_system.version,
existing_system.max_instances,
', '.join(existing_system.instance_names)))
# We always update in case the metadata has changed.
self.system = self.bm_client.update_system(existing_system.id,
new_commands=new_commands,
metadata=self.system.metadata,
description=self.system.description,
display_name=self.system.display_name,
icon_name=self.system.icon_name)
else:
self.system = self.bm_client.create_system(self.system)
# Sanity check to make sure an instance with this name was registered
if self.system.has_instance(self.instance_name):
instance_id = self.system.get_instance(self.instance_name).id
else:
raise PluginValidationError('Unable to find registered instance with name "%s"' %
self.instance_name)
self.instance = self.bm_client.initialize_instance(instance_id)
self.queue_connection_params = self.instance.queue_info.get('connection', None)
if self.queue_connection_params and self.queue_connection_params.get('ssl', None):
self.queue_connection_params['ssl'].update({
'ca_cert': self.ca_cert,
'ca_verify': self.ca_verify,
'client_cert': self.client_cert,
})
self.logger.debug("Plugin %s is initialized", self.unique_name)
def _setup_system(self, system, plugin_kwargs):
helper_keywords = {
"name",
"version",
"description",
"icon_name",
"display_name",
"max_instances",
"metadata",
"namespace",
"template",
}
if system:
if helper_keywords.intersection(plugin_kwargs.keys()):
raise ValidationError(
"Sorry, you can't provide a complete system definition as well as "
"system creation helper kwargs %s" % helper_keywords
)
if not system.instances:
raise ValidationError(
"Explicit system definition requires explicit instance "
"definition (use instances=[Instance(name='default')] for "
"default behavior)"
)
if not system.max_instances:
system.max_instances = len(system.instances)
else:
# Commands are not defined here - they're set in the client property setter
system = System(
name=self._config.name,
version=self._config.version,
description=self._config.description,
namespace=self._config.namespace,
metadata=json.loads(self._config.metadata),
instances=[Instance(name=self._config.instance_name)],
max_instances=self._config.max_instances,
icon_name=self._config.icon_name,
display_name=self._config.display_name,
template=self._config.template,
)
return system
def setUp(self):
self.app = brew_view.app.test_client()
self.default_instance = Instance(name='default', status='RUNNING')
self.default_command = Command(id='54ac18f778c4b57e963f3c18',
name='command',
description='foo')
self.default_system = System(id='54ac18f778c4b57e963f3c18',
name='default_system',
version='1.0.0',
instances=[self.default_instance],
commands=[self.default_command])
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
def test_existing(self, loader, registry, plugin_1):
system_id = "58542eb571afd47ead90face"
instance_id = "58542eb571afd47ead90beef"
create_system(
System(
id=system_id,
name="foo",
version="1.0",
instances=[Instance(id=instance_id)],
)
)
plugin_runners = loader.load_plugin(plugin_1)
assert len(plugin_runners) == 1
assert str(plugin_runners[0].system.id) == system_id
assert str(plugin_runners[0].instance.id) == instance_id
assert plugin_runners[0].name == "foo[default]-1.0"
assert plugin_runners[0].entry_point == "entry.py"
def setUp(self):
self.app = brew_view.app.test_client()
self.default_instance = Instance(name="default", status="RUNNING")
self.default_command = Command(
id="54ac18f778c4b57e963f3c18", name="command", description="foo"
)
self.default_system = System(
id="54ac18f778c4b57e963f3c18",
name="default_system",
version="1.0.0",
instances=[self.default_instance],
commands=[self.default_command],
)
self.client_mock = Mock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
def setUp(self):
self.safe_copy = os.environ.copy()
consumer_patcher = patch('brewtils.plugin.RequestConsumer')
self.addCleanup(consumer_patcher.stop)
self.consumer_patch = consumer_patcher.start()
self.instance = Instance(id='id', name='default', queue_type='rabbitmq',
queue_info={'url': 'url', 'admin': {'name': 'admin_queue'},
'request': {'name': 'request_queue'}})
self.system = System(name='test_system', version='1.0.0', instances=[self.instance],
metadata={'foo': 'bar'})
self.client = MagicMock(name='client', spec='command', _commands=['command'])
self.plugin = PluginBase(self.client, bg_host='localhost', system=self.system,
metadata={'foo': 'bar'})
self.plugin.instance = self.instance
self.bm_client_mock = Mock(create_system=Mock(return_value=self.system),
initialize_instance=Mock(return_value=self.instance))
self.plugin.bm_client = self.bm_client_mock
self.parser_mock = Mock()
self.plugin.parser = self.parser_mock
def __repr__(self):
return BrewtilsInstance.__repr__(self)
def _initialize_system(self):
"""Let Beergarden know about System-level info
This will attempt to find a system with a name and version matching this plugin.
If one is found this will attempt to update it (with commands, metadata, etc.
from this plugin).
If a System is not found this will attempt to create one.
Returns:
Definition of a Beergarden System this plugin belongs to.
Raises:
PluginValidationError: Unable to find or create a System for this Plugin
"""
# Make sure that the system is actually valid before trying anything
self._validate_system()
# Do any necessary template resolution
self._system.template = resolve_template(self._system.template)
existing_system = self._ez_client.find_unique_system(
name=self._system.name,
version=self._system.version,
namespace=self._system.namespace,
)
if not existing_system:
try:
# If this succeeds can just finish here
return self._ez_client.create_system(self._system)
except ConflictError:
# If multiple instances are starting up at once and this is a new system
# the create can return a conflict. In that case just try the get again
existing_system = self._ez_client.find_unique_system(
name=self._system.name,
version=self._system.version,
namespace=self._system.namespace,
)
# If we STILL can't find a system something is really wrong
if not existing_system:
raise PluginValidationError(
"Unable to find or create system {0}".format(self._system)
)
# We always update with these fields
update_kwargs = {
"new_commands": self._system.commands,
"metadata": self._system.metadata,
"description": self._system.description,
"display_name": self._system.display_name,
"icon_name": self._system.icon_name,
"template": self._system.template,
}
# And if this particular instance doesn't exist we want to add it
if not existing_system.has_instance(self._config.instance_name):
update_kwargs["add_instance"] = Instance(name=self._config.instance_name)
return self._ez_client.update_system(existing_system.id, **update_kwargs)
def test_repr(self):
instance = Instance(name='name', status='RUNNING')
assert 'name' in repr(instance)
assert 'RUNNING' in repr(instance)
def test_setup_system_no_max_instances(self):
system = System(name='test_system', version='1.0.0', instances=[Instance(name='1'),
Instance(name='2')])
new_system = self.plugin._setup_system(self.client, 'default', system, '', '', '', '', {},
None, None)
self.assertEqual(2, new_system.max_instances)
def bg_instance(instance_dict, ts_dt):
"""An instance as a model."""
dict_copy = copy.deepcopy(instance_dict)
dict_copy['status_info']['heartbeat'] = ts_dt
return Instance(**dict_copy)
def default_system(self, command1):
return System(name='foo',
version='1.0.0',
instances=[Instance(name='foo')],
commands=[command1])
def test_repr(self):
instance = Instance(name="name", status="RUNNING")
assert "name" in repr(instance)
assert "RUNNING" in repr(instance)
def test_str(self):
assert "name" == str(Instance(name="name"))
def test_str(self):
assert 'name' == str(Instance(name='name'))
