class BackupConfigurationTests(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.plumbery.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
self.facility = PlumberyFacility(
plumbery=self.plumbery, fittings=myFacility)
self.facility.power_on()
def test_backup_validation_valid(self):
settings = {
'backup': 'essentials'
}
config = backup.BackupConfiguration(engine=None, facility=None)
self.assertTrue(config.validate(settings))
def test_backup_validation_invalid(self):
settings = {
'backup': 'potato'
}
config = backup.BackupConfiguration(engine=None, facility=None)
with self.assertRaises(ConfigurationError):
config.validate(settings)
def test_backup_configuration(self):
settings = {
'backup': 'essentials',
}
config = backup.BackupConfiguration(self.plumbery, self.facility)
backupConfiguration = config.configure(TestNode(), settings)
self.assertTrue(backupConfiguration)
def test_lifecycle(self):
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
try:
self.engine.build_all_blueprints()
self.engine.build_blueprint('myBlueprint')
self.engine.start_all_nodes()
self.engine.start_nodes('myBlueprint')
self.engine.polish_all_blueprints()
self.engine.polish_blueprint('myBlueprint')
self.engine.stop_all_nodes()
self.engine.stop_nodes('myBlueprint')
self.engine.destroy_all_nodes()
self.engine.destroy_nodes('myBlueprint')
self.engine.destroy_all_blueprints()
self.engine.destroy_blueprint('myBlueprint')
except socket.gaierror:
pass
except InvalidCredsError:
pass
def test_settings(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_setting('locationId'), 'EU6')
self.assertEqual(facility.get_setting('regionId'), 'dd-eu')
self.assertEqual(facility.get_setting('prepare'), None)
self.assertEqual(facility.get_setting('basement'), 'myBlueprint')
def test_settings(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_setting('locationId'), 'EU6')
self.assertEqual(facility.get_setting('regionId'), 'dd-eu')
self.assertEqual(facility.get_setting('prepare'), None)
self.assertEqual(facility.get_setting('basement'), 'myBlueprint')
def test_settings_private(self):
engine = PlumberyEngine()
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
engine.set_fittings(myPrivatePlan)
facilities = engine.list_facility('quasimoto.com')
self.assertEqual(len(facilities), 1)
facilities[0].power_on()
def test_get_parameter(self):
engine = PlumberyEngine()
engine.from_text(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_parameter('locationId'), 'EU6')
self.assertEqual(facility.get_parameter('regionId'), 'dd-eu')
self.assertEqual(facility.get_parameter('rub'), None)
self.assertEqual(facility.get_parameter('ipv4'), 'auto')
self.assertEqual(facility.get_parameter('basement'), 'myBlueprint')
def test_secrets(self):
engine = PlumberyEngine()
engine.secrets = {'hello': 'world'}
engine.save_secrets(plan='test_engine.yaml')
engine.secrets = {}
engine.load_secrets(plan='test_engine.yaml')
self.assertEqual(engine.secrets['hello'], 'world')
engine.forget_secrets(plan='test_engine.yaml')
self.assertEqual(os.path.isfile('.test_engine.secrets'), False)
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.plumbery.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
self.facility = PlumberyFacility(
plumbery=self.plumbery, fittings=fakeFittings)
self.facility.power_on()
def test_bad_args(self):
engine = PlumberyEngine()
engine.set_fittings(myPlan)
with self.assertRaises(SystemExit):
main(['bad args'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'xyz123', 'web'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '@'], engine)
def test_bad_args(self):
engine = PlumberyEngine()
engine.set_fittings(myPlan)
with self.assertRaises(SystemExit):
main(['bad args'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'xyz123', 'web'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '@'], engine)
def test_secrets(self):
engine = PlumberyEngine()
engine.secrets = {'hello': 'world'}
engine.save_secrets(plan='test_engine.yaml')
engine.secrets = {}
engine.load_secrets(plan='test_engine.yaml')
self.assertEqual(engine.secrets['hello'], 'world')
engine.forget_secrets(plan='test_engine.yaml')
self.assertEqual(os.path.isfile('.test_engine.secrets'), False)
def test_init(self):
engine = PlumberyEngine()
engine.from_text(myPlan)
self.assertEqual(engine.safeMode, False)
self.assertEqual(len(engine.information), 2)
self.assertEqual(len(engine.links), 1)
domain = engine.get_default('domain')
self.assertEqual(domain['ipv4'], 'auto')
cloudConfig = engine.get_default('cloud-config', {})
self.assertEqual(len(cloudConfig.keys()), 3)
parameter = engine.get_parameter('locationId')
self.assertEqual(parameter, 'EU6')
parameter = engine.get_parameter('domainName')
self.assertEqual(parameter, 'myDC')
parameter = engine.get_parameter('networkName')
self.assertEqual(parameter, 'myVLAN')
self.assertEqual(len(engine.facilities), 1)
facility = engine.facilities[0]
self.assertEqual(facility.settings['locationId'], 'EU6')
self.assertEqual(facility.settings['regionId'], 'dd-eu')
blueprint = facility.blueprints[0]['myBlueprint']
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
def test_lifecycle(self):
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
try:
self.engine.build_all_blueprints()
self.engine.build_blueprint('myBlueprint')
self.engine.start_all_nodes()
self.engine.start_nodes('myBlueprint')
self.engine.stop_all_nodes()
self.engine.stop_nodes('myBlueprint')
self.engine.destroy_all_nodes()
self.engine.destroy_nodes('myBlueprint')
except socket.gaierror:
pass
except InvalidCredsError:
pass
def test_configure(self):
settings = {
'safeMode': False,
'polishers': [
{'ansible': {}},
{'spit': {}},
]
}
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
self.engine.configure(settings)
self.assertEqual(self.engine.safeMode, False)
try:
self.engine.setup(io.TextIOWrapper(io.BytesIO(myPlan)))
self.engine.add_facility(myFacility)
self.assertEqual(len(self.engine.facilities), 2)
except socket.gaierror:
pass
except InvalidCredsError:
pass
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
self.fittings = PlumberyFittings(**fakeFittings)
self.facility = PlumberyFacility(plumbery=self.plumbery, fittings=self.fittings)
self.facility.region = FakeRegion()
def test_settings(self):
engine = PlumberyEngine()
engine.from_text(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_setting('locationId'), 'EU6')
self.assertEqual(facility.get_setting('regionId'), 'dd-eu')
self.assertEqual(facility.get_setting('rub'), None)
self.assertEqual(facility.get_setting('basement'), 'myBlueprint')
city = facility.get_city()
self.assertEqual(city, 'Frankfurt')
self.assertEqual(city, facility.get_city('EU6'))
coordinates = facility.get_coordinates()
self.assertEqual(len(coordinates), 2)
self.assertEqual(coordinates, facility.get_coordinates('EU6'))
def test_lookup(self):
self.engine = PlumberyEngine()
self.assertEqual(self.engine.lookup('plumbery.version'), __version__)
random = self.engine.lookup('random.secret')
self.assertEqual(len(random), 9)
self.assertEqual(self.engine.lookup('random.secret'), random)
class TestPlumberyFacility(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
self.fittings = PlumberyFittings(**fakeFittings)
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.facility = PlumberyFacility(plumbery=self.plumbery,
fittings=self.fittings)
self.facility.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
def tearDown(self):
self.facility = None
def test_build_all_blueprints(self):
self.facility.build_all_blueprints()
def test_build_blueprint(self):
self.facility.build_blueprint('fake')
def test_destroy_all_nodes(self):
self.facility.destroy_all_nodes()
def test_destroy_nodes(self):
self.facility.destroy_nodes('fake')
def test_focus(self):
self.facility.focus()
def test_get_blueprint(self):
self.facility.get_blueprint('fake')
def test_start_all_nodes(self):
self.facility.start_all_nodes()
def test_start_nodes(self):
self.facility.start_nodes('fake')
def test_stop_all_nodes(self):
self.facility.stop_all_nodes()
def test_stop_nodes(self):
self.facility.stop_nodes('fake')
def test_init(self):
engine = PlumberyEngine()
engine.set_fittings(myPlan)
self.assertEqual(engine.buildPolisher, 'alien')
domain = engine.get_default('domain')
self.assertEqual(domain['ipv4'], 'auto')
cloudConfig = engine.get_default('cloud-config', {})
self.assertEqual(len(cloudConfig.keys()), 5)
self.assertEqual(len(engine.information), 2)
self.assertEqual(len(engine.links), 1)
parameters = engine.get_parameters()
self.assertEqual(parameters['parameter.locationId'], 'EU6')
self.assertEqual(parameters['parameter.domainName'], 'myDC')
self.assertEqual(parameters['parameter.networkName'], 'myVLAN')
parameter = engine.get_parameter('locationId')
self.assertEqual(parameter, 'EU6')
parameter = engine.get_parameter('domainName')
self.assertEqual(parameter, 'myDC')
parameter = engine.get_parameter('networkName')
self.assertEqual(parameter, 'myVLAN')
self.assertEqual(len(engine.polishers), 3)
for polisher in engine.polishers:
self.assertTrue(isinstance(polisher, PlumberyPolisher))
self.assertEqual(engine.safeMode, False)
self.assertEqual(len(engine.facilities), 1)
facility = engine.facilities[0]
self.assertEqual(facility.settings['locationId'], 'EU6')
self.assertEqual(facility.settings['regionId'], 'dd-eu')
blueprint = facility.blueprints[0]['myBlueprint']
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
def test_init(self):
engine = PlumberyEngine()
engine.set_fittings(myPlan)
self.assertEqual(engine.buildPolisher, 'alien')
domain = engine.get_default('domain')
self.assertEqual(domain['ipv4'], 'auto')
cloudConfig = engine.get_default('cloud-config', {})
self.assertEqual(len(cloudConfig.keys()), 5)
self.assertEqual(len(engine.information), 2)
self.assertEqual(len(engine.links), 1)
parameters = engine.get_parameters()
self.assertEqual(parameters['parameter.locationId'],
'EU6')
self.assertEqual(parameters['parameter.domainName'],
'myDC')
self.assertEqual(parameters['parameter.networkName'],
'myVLAN')
parameter = engine.get_parameter('locationId')
self.assertEqual(parameter, 'EU6')
parameter = engine.get_parameter('domainName')
self.assertEqual(parameter, 'myDC')
parameter = engine.get_parameter('networkName')
self.assertEqual(parameter, 'myVLAN')
self.assertEqual(len(engine.polishers), 3)
for polisher in engine.polishers:
self.assertTrue(isinstance(polisher, PlumberyPolisher))
self.assertEqual(engine.safeMode, False)
self.assertEqual(len(engine.facilities), 1)
facility = engine.facilities[0]
self.assertEqual(facility.settings['locationId'], 'EU6')
self.assertEqual(facility.settings['regionId'], 'dd-eu')
blueprint = facility.blueprints[0]['myBlueprint']
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.facility = PlumberyFacility(
plumbery=self.plumbery, fittings=fakeFittings)
self.facility.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
def do_polish(polisher):
engine = PlumberyEngine()
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
engine.from_text(myInformation)
polisher.go(engine)
facility = engine.list_facility('NA9')[0]
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
facility.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
polisher.move_to(facility)
blueprint = facility.get_blueprint('test')
infrastructure = PlumberyInfrastructure(facility)
container = infrastructure.get_container(blueprint)
polisher.shine_container(container)
nodes = PlumberyNodes(facility)
node = nodes.get_node('stackstorm')
polisher.shine_node(
node=node, settings=fakeNodeSettings, container=container)
node = nodes.get_node('node1')
polisher.shine_node(
node=node, settings=fakeNodeSettings, container=container)
polisher.move_to(FakeFacility())
polisher.shine_container(FakeContainer())
polisher.shine_node(
node=FakeNode(), settings=fakeNodeSettings, container=FakeContainer())
polisher.reap()
class TestPlumberyFacility(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
self.fittings = PlumberyFittings(**fakeFittings)
self.facility = PlumberyFacility(plumbery=self.plumbery, fittings=self.fittings)
self.facility.region = FakeRegion()
def tearDown(self):
self.facility = None
def test_build_all_blueprints(self):
self.facility.build_all_blueprints()
def test_build_blueprint(self):
self.facility.build_blueprint('fake')
def test_destroy_all_nodes(self):
self.facility.destroy_all_nodes()
def test_destroy_nodes(self):
self.facility.destroy_nodes('fake')
def test_focus(self):
self.facility.focus()
def test_get_blueprint(self):
self.facility.get_blueprint('fake')
def test_start_all_nodes(self):
self.facility.start_all_nodes()
def test_start_nodes(self):
self.facility.start_nodes('fake')
def test_stop_all_nodes(self):
self.facility.stop_all_nodes()
def test_stop_nodes(self):
self.facility.stop_nodes('fake')
def test_defaults(self):
engine = PlumberyEngine()
engine.from_text(defaultsPlan)
self.assertEqual(engine.get_default('locationId'), 'EU6')
self.assertEqual(engine.get_default('regionId'), 'dd-eu')
self.assertEqual(engine.get_default('ipv4'), 'auto')
class FakeFacility:
plumbery = PlumberyEngine()
region = FakeRegion()
def list_nodes(self):
return ['mongo_mongos01', 'mongo_mongos02']
def power_on(self):
pass
def get_location_id(self):
return 'EU6'
def test_blueprints(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
blueprint = facility.get_blueprint('myBlueprint')
self.assertEqual(isinstance(blueprint, dict), True)
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['domain']['ipv4'], 'auto')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
self.assertEqual(blueprint['ethernet']['subnet'], '10.1.10.0')
self.assertEqual(len(blueprint['ethernet']['accept']), 1)
label = list(blueprint['nodes'][0])[0]
node = blueprint['nodes'][0][label]
self.assertEqual('default' not in node, True)
self.assertEqual(node['cpu'], 3)
self.assertEqual(node['memory'], 5)
self.assertEqual(len(node['information']), 2)
config = node['cloud-config']
self.assertEqual(isinstance(config, dict), True)
self.assertEqual(config['disable_root'], True)
self.assertEqual(config['ssh_pwauth'], True)
self.assertEqual(len(config['packages']), 4)
self.assertEqual(len(config['runcmd']), 4)
def do_polish(polisher):
engine = PlumberyEngine(myInformation)
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
polisher.go(engine)
facility = engine.list_facility('NA9')[0]
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
facility.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
polisher.move_to(facility)
blueprint = facility.get_blueprint('test')
infrastructure = PlumberyInfrastructure(facility)
container = infrastructure.get_container(blueprint)
polisher.shine_container(container)
nodes = PlumberyNodes(facility)
node = nodes.get_node('stackstorm')
polisher.shine_node(node=node,
settings=fakeNodeSettings,
container=container)
node = nodes.get_node('node1')
polisher.shine_node(node=node,
settings=fakeNodeSettings,
container=container)
polisher.move_to(FakeFacility())
polisher.shine_container(FakeContainer())
polisher.shine_node(node=FakeNode(),
settings=fakeNodeSettings,
container=FakeContainer())
polisher.reap()
def test_blueprints(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
blueprint = facility.get_blueprint('myBlueprint')
self.assertEqual(isinstance(blueprint, dict), True)
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['domain']['ipv4'], 'auto')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
self.assertEqual(blueprint['ethernet']['subnet'], '10.1.10.0')
self.assertEqual(len(blueprint['ethernet']['accept']), 1)
label = list(blueprint['nodes'][0])[0]
node = blueprint['nodes'][0][label]
self.assertEqual('default' not in node, True)
self.assertEqual(node['cpu'], 3)
self.assertEqual(node['memory'], 5)
self.assertEqual(len(node['information']), 2)
config = node['cloud-config']
self.assertEqual(isinstance(config, dict), True)
self.assertEqual(config['disable_root'], True)
self.assertEqual(config['ssh_pwauth'], True)
self.assertEqual(len(config['packages']), 4)
self.assertEqual(len(config['runcmd']), 4)
def test_engine(self):
engine = PlumberyEngine()
context = PlumberyContext(context=engine)
template = "we are running plumbery {{ plumbery.version }}"
expected = "we are running plumbery " + __version__
self.assertEqual(self.text.expand_string(template, context), expected)
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
template = "{{ name.credentials }} {{ password.credentials }}"
expected = engine.get_user_name() + " " + engine.get_user_password()
self.assertEqual(self.text.expand_string(template, context), expected)
def process(self, item, counter):
"""
Processes one action
Example actions:
('deploy', '')
('dispose', '')
"""
print('Worker is working on {}'.format(counter))
(verb, parameters) = item
try:
fittings = self.context.get('plumbery.fittings', '.') \
+'/'+self.context.get('worker.template', 'example/first') \
+'/fittings.yaml'
print('- reading {}'.format(fittings))
print('- loading plumbery engine')
engine = PlumberyEngine(fittings)
except Exception as feedback:
print("Error while reading fittings plan")
self.outbox.put("Error while reading fittings plan")
return
try:
engine.do(verb)
self.outbox.put(engine.document_elapsed())
except Exception as feedback:
print("Unable to do '{}'".format(verb))
self.outbox.put("Unable to do '{}'".format(verb))
return
def test_main(self):
engine = PlumberyEngine()
engine.set_fittings(myPlan)
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
with self.assertRaises(SystemExit):
main(['bad args'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'xyz123', 'web'], engine)
with self.assertRaises(SystemExit):
main(['-v'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '-v'], engine)
def test_settings_private(self):
settings = {
'apiHost': 'smee.com',
'locationId': 'NA5',
'safeMode': True
}
engine = PlumberyEngine(plan=settings)
engine.set_user_name('smee')
engine.set_user_password('smee')
facility = engine.list_facility()[0]
# facility.power_on()
self.assertEqual(facility.get_setting('locationId'), 'NA5')
self.assertIsNone(facility.get_setting('regionId'))
def test_set(self):
settings = {
'safeMode': False,
'polishers': [
{
'ansible': {}
},
{
'spit': {}
},
]
}
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
self.engine.set(settings)
self.assertEqual(self.engine.safeMode, False)
try:
self.engine.from_text(myPlan)
self.engine.add_facility(myFacility)
self.assertEqual(len(self.engine.facilities), 2)
except socket.gaierror:
pass
except InvalidCredsError:
pass
def test_main(self):
engine = PlumberyEngine()
engine.from_text(myPlan)
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
with self.assertRaises(SystemExit):
main(['bad args'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'xyz123', 'web'], engine)
with self.assertRaises(SystemExit):
main(['-v'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '-v'], engine)
def test_settings_private(self):
settings = {
'apiHost': 'smee.com',
'locationId': 'NA5',
'safeMode': True
}
engine = PlumberyEngine(plan=settings)
engine.set_user_name('smee')
engine.set_user_password('smee')
facility = engine.list_facility()[0]
# facility.power_on()
self.assertEqual(facility.get_setting('locationId'), 'NA5')
self.assertIsNone(facility.get_setting('regionId'))
def test_main(self):
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '@EU6'])
engine = PlumberyEngine()
engine.set_fittings(myPlan)
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
with self.assertRaises(SystemExit):
main(['-v'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '-v'], engine)
with self.assertRaises(SystemExit):
main(['fittings.yaml', 'build', 'web', '@EU6'], engine)
def test_engine(self):
engine = PlumberyEngine()
context = PlumberyContext(context=engine)
template = "we are running plumbery {{ plumbery.version }}"
expected = "we are running plumbery "+__version__
self.assertEqual(
self.text.expand_string(template, context), expected)
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
template = "{{ name.credentials }} {{ password.credentials }}"
expected = engine.get_user_name()+" "+engine.get_user_password()
self.assertEqual(
self.text.expand_string(template, context), expected)
def test_set(self):
settings = {
'safeMode': False,
'polishers': [
{'ansible': {}},
{'spit': {}},
]
}
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
random = self.engine.get_secret('random')
self.assertEqual(len(random), 9)
self.assertEqual(self.engine.get_secret('random'), random)
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
self.engine.set(settings)
self.assertEqual(self.engine.safeMode, False)
try:
self.engine.from_text(myPlan)
cloudConfig = self.engine.get_cloud_config()
self.assertEqual(len(cloudConfig.keys()), 3)
self.engine.add_facility(myFacility)
self.assertEqual(len(self.engine.facilities), 2)
except socket.gaierror:
pass
except InvalidCredsError:
pass
class TestPlumberyEngine(unittest.TestCase):
def test_configure(self):
settings = {
'safeMode': False,
'polishers': [
{'ansible': {}},
{'spit': {}},
]
}
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
self.engine.configure(settings)
self.assertEqual(self.engine.safeMode, False)
try:
self.engine.setup(io.TextIOWrapper(io.BytesIO(myPlan)))
self.engine.add_facility(myFacility)
self.assertEqual(len(self.engine.facilities), 2)
except socket.gaierror:
pass
except InvalidCredsError:
pass
def test_lifecycle(self):
self.engine = PlumberyEngine()
self.engine.set_shared_secret('fake_secret')
self.assertEqual(self.engine.get_shared_secret(), 'fake_secret')
self.engine.set_user_name('fake_name')
self.assertEqual(self.engine.get_user_name(), 'fake_name')
self.engine.set_user_password('fake_password')
self.assertEqual(self.engine.get_user_password(), 'fake_password')
try:
self.engine.build_all_blueprints()
self.engine.build_blueprint('myBlueprint')
self.engine.start_all_nodes()
self.engine.start_nodes('myBlueprint')
self.engine.stop_all_nodes()
self.engine.stop_nodes('myBlueprint')
self.engine.destroy_all_nodes()
self.engine.destroy_nodes('myBlueprint')
except socket.gaierror:
pass
except InvalidCredsError:
pass
def test_get_default(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
infrastructure = PlumberyInfrastructure(facility)
self.assertEqual(infrastructure.get_default('ipv4'), 'auto')
def test_lookup(self):
engine = PlumberyEngine()
self.assertEqual(engine.lookup('plumbery.version'), __version__)
engine.secrets = {}
random = engine.lookup('secret.random')
self.assertEqual(len(random), 9)
self.assertEqual(engine.lookup('secret.random'), random)
md5 = engine.lookup('secret.random.md5')
self.assertEqual(len(md5), 32)
self.assertNotEqual(md5, random)
sha = engine.lookup('secret.random.sha1')
self.assertEqual(len(sha), 40)
self.assertNotEqual(sha, random)
sha = engine.lookup('secret.random.sha256')
self.assertEqual(len(sha), 64)
self.assertNotEqual(sha, random)
id1 = engine.lookup('id1.uuid')
self.assertEqual(len(id1), 36)
self.assertEqual(engine.lookup('id1.uuid'), id1)
id2 = engine.lookup('id2.uuid')
self.assertEqual(len(id2), 36)
self.assertNotEqual(id1, id2)
engine.lookup('application.secret')
engine.lookup('database.secret')
engine.lookup('master.secret')
engine.lookup('slave.secret')
original = b'hello world'
if HAS_CRYPTO:
text = engine.lookup('pair1.rsa_public')
self.assertTrue(ensure_string(text).startswith('ssh-rsa '))
key = RSA.importKey(text)
cipher = PKCS1_OAEP.new(key)
encrypted = cipher.encrypt(original)
privateKey = engine.lookup('pair1.rsa_private')
self.assertTrue(
ensure_string(privateKey).startswith(
'-----BEGIN RSA PRIVATE KEY-----'))
key = RSA.importKey(engine.lookup('pair1.rsa_private'))
cipher = PKCS1_OAEP.new(key)
decrypted = cipher.decrypt(encrypted)
self.assertEqual(decrypted, original)
token = engine.lookup('https://discovery.etcd.io/new')
self.assertEqual(token.startswith('https://discovery.etcd.io/'),
True)
self.assertEqual(len(token), 58)
self.assertEqual(len(engine.secrets), 13)
with self.assertRaises(LookupError):
localKey = engine.lookup('local.rsa_private')
localKey = engine.lookup('rsa_public.local')
try:
path = '~/.ssh/id_rsa.pub'
with open(os.path.expanduser(path)) as stream:
text = stream.read()
stream.close()
self.assertEqual(localKey.strip(), text.strip())
plogging.info("Successful lookup of local public key")
except IOError:
pass
def test_as_library(self):
engine = PlumberyEngine(myEuropeanPlan, myAmericanBinding)
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
facilities = engine.list_facility('NA9')
self.assertEqual(len(facilities), 1)
facility = facilities[0]
self.assertEqual(facility.get_setting('regionId'), 'dd-na')
self.assertEqual(facility.get_setting('locationId'), 'NA9')
self.assertTrue(facility.get_blueprint('fake') is None)
blueprint = facility.get_blueprint('myBlueprint')
node = blueprint['nodes'][0]
self.assertEqual(list(node)[0], 'toto')
config = node['toto']['cloud-config']
self.assertEqual(config['hostname'], 'toto')
self.assertEqual(config['write_files'][0]['content'].count('toto'), 6)
engine.do('deploy')
engine.do('dispose')
def test_remote_params(self):
engine = PlumberyEngine()
with requests_mock.mock() as m:
m.get('http://smee.com/params.yml', text=yaml.dump(myParameters))
engine.set_parameters('http://smee.com/params.yml')
def test_process_blueprint(self):
engine = PlumberyEngine()
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
engine.set_fittings(myPrivatePlan)
engine.process_blueprint(action='dummy', names='fake')
action = FakeAction({})
engine.process_blueprint(action, names='fake')
self.assertEqual(action.count, 205)
class TestPlumberyFacility(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.plumbery.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
self.facility = PlumberyFacility(
plumbery=self.plumbery, fittings=fakeFittings)
self.facility.power_on()
def tearDown(self):
self.facility = None
def test_get_location_id(self):
self.assertEqual(self.facility.get_location_id(), 'NA9')
def test_list_basement(self):
self.assertEqual(self.facility.list_basement(), ['fake1'])
def test_list_blueprints(self):
self.assertEqual(self.facility.list_blueprints(), ['fake1', 'fake2'])
def test_expand_blueprint(self):
self.assertEqual(
self.facility.expand_blueprint('fake1'), ['fake1'])
self.assertEqual(
self.facility.expand_blueprint('fake1 unknown fake'), ['fake1'])
self.assertEqual(
self.facility.expand_blueprint('macro'), ['fake2'])
self.assertEqual(
self.facility.expand_blueprint('basement'), ['fake1'])
def test_get_blueprint(self):
self.assertEqual(
self.facility.get_blueprint('fake2')['target'], 'fake2')
self.assertIsNone(self.facility.get_blueprint('macro'))
self.assertIsNone(self.facility.get_blueprint('crazyAndunknown'))
def test_list_domains(self):
self.assertEqual(self.facility.list_domains(), ['VDC1'])
def test_list_ethernets(self):
self.assertEqual(self.facility.list_ethernets(), ['vlan1'])
def test_list_nodes(self):
self.assertEqual(self.facility.list_nodes(),
['stackstorm1', 'stackstorm2'])
def test_get_image(self):
self.assertRegexpMatches(
self.facility.get_image().name, "^RedHat ")
self.assertIsNone(self.facility.get_image('perfectlyUnknown'))
def test_focus(self):
self.facility.focus()
def test_process_all_blueprints(self):
action = FakeAction({})
self.facility.process_all_blueprints(action)
self.assertEqual(action.count, 14)
def test_process_blueprint(self):
action = FakeAction({})
self.facility.process_blueprint(action, names='fake')
self.assertEqual(action.count, 4)
def test_build_all_blueprints(self):
self.facility.build_all_blueprints()
def test_build_blueprint(self):
self.facility.build_blueprint('fake')
def test_start_all_blueprints(self):
self.facility.start_all_blueprints()
def test_start_blueprint(self):
self.facility.start_blueprint('fake')
def test_polish_all_blueprints(self):
self.facility.polish_all_blueprints(polishers='ping')
def test_polish_blueprint(self):
self.facility.polish_blueprint(names='fake', polishers='ping')
def test_stop_all_blueprints(self):
self.facility.stop_all_blueprints()
def test_stop_blueprint(self):
self.facility.stop_blueprint('fake')
def test_wipe_all_blueprints(self):
self.facility.wipe_all_blueprints()
def test_wipe_blueprint(self):
self.facility.wipe_blueprint('fake')
def test_destroy_all_blueprints(self):
self.facility.destroy_all_blueprints()
def test_destroy_blueprint(self):
self.facility.destroy_blueprint('fake')
def test_lookup(self):
self.assertEqual(self.facility.lookup('location.country'), 'US')
self.assertEqual(self.facility.lookup('location.id'), 'NA9')
self.assertEqual(self.facility.lookup('*unknown*'), None)
def test_settings(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_setting('locationId'), 'EU6')
self.assertEqual(facility.get_setting('regionId'), 'dd-eu')
self.assertEqual(facility.get_setting('prepare'), None)
self.assertEqual(facility.get_setting('basement'), 'myBlueprint')
def test_settings_private(self):
settings = {
'apiHost': 'smee.com',
'locationId': 'NA5',
'safeMode': True
}
engine = PlumberyEngine(plan=settings)
engine.set_user_name('smee')
engine.set_user_password('smee')
facility = engine.list_facility()[0]
# facility.power_on()
self.assertEqual(facility.get_setting('locationId'), 'NA5')
self.assertIsNone(facility.get_setting('regionId'))
def test_blueprints(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
blueprint = facility.get_blueprint('myBlueprint')
self.assertEqual(isinstance(blueprint, dict), True)
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['domain']['ipv4'], 'auto')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
self.assertEqual(blueprint['ethernet']['subnet'], '10.1.10.0')
self.assertEqual(len(blueprint['ethernet']['accept']), 1)
label = list(blueprint['nodes'][0])[0]
node = blueprint['nodes'][0][label]
self.assertEqual('default' not in node, True)
self.assertEqual(node['cpu'], 3)
self.assertEqual(node['memory'], 5)
self.assertEqual(len(node['information']), 2)
config = node['cloud-config']
self.assertEqual(isinstance(config, dict), True)
self.assertEqual(config['disable_root'], True)
self.assertEqual(config['ssh_pwauth'], True)
self.assertEqual(len(config['packages']), 4)
self.assertEqual(len(config['runcmd']), 4)
def main(args=None, engine=None):
"""
Runs plumbery from the command line
:param args: arguments to be considered for this invocation
:type args: a list of ``str``
:param engine: an instance of the plumbery engine
:type engine: :class:`plumbery.PlumberEngine`
Example::
$ python -m plumbery fittings.yaml build web
In this example, plumbery loads fittings plan from ``fittings.yaml``, then
it builds the blueprint named ``web``.
If no blueprint is mentioned, then plumbery looks at all blueprint
definitions in the fittings plan. In other terms, the following command
builds the entire fittings plan, eventually across multiple facilities::
$ python -m plumbery fittings.yaml build
Of course, plumbery can be invoked through the entire life cycle of your
fittings::
$ python -m plumbery fittings.yaml build
$ python -m plumbery fittings.yaml start
$ python -m plumbery fittings.yaml polish
... nodes are up and running ...
$ python -m plumbery fittings.yaml stop
... nodes have been stopped ...
$ python -m plumbery fittings.yaml wipe
... nodes have been destroyed, but the infrastructure remains ...
$ python -m plumbery fittings.yaml destroy
... every virtual resources has been removed ...
To focus at a single location, put the character '@' followed by the id.
For example, to build fittings only at 'NA12' you would type::
$ python -m plumbery fittings.yaml build @NA12
To focus on one blueprint just mention its name on the command line.
For example, if fittings plan has a blueprint for nodes running Docker,
then you may use following statements to bootstrap each node::
$ python -m plumbery fittings.yaml build docker
$ python -m plumbery fittings.yaml start docker
$ python -m plumbery fittings.yaml prepare docker
... Docker is up and running at multiple nodes ...
If you create a new polisher and put it in the directory
``plumbery\polishers``, then it will become automatically available::
$ python -m plumbery fittings.yaml my_special_stuff
To get some help, you can type::
$ python -m plumbery -h
"""
# part 1 - understand what the user wants
if args is None:
args = sys.argv[1:]
try:
args = parse_args(args)
except Exception as feedback:
plogging.error("Incorrect arguments. "
"Maybe the following can help: python -m plumbery -h")
if plogging.getEffectiveLevel() == logging.DEBUG:
raise
else:
plogging.error("{}: {}".format(feedback.__class__.__name__,
str(feedback)))
sys.exit(2)
# part 2 - get a valid and configured engine
if engine is None:
try:
engine = PlumberyEngine(args.fittings, args.parameters)
if args.safe:
engine.safeMode = True
except Exception as feedback:
if plogging.getEffectiveLevel() == logging.DEBUG:
plogging.error("Cannot read fittings plan from '{}'".format(
args.fittings))
raise
else:
plogging.error("Cannot read fittings plan from '{}'"
", run with -d for debug".format(args.fittings))
plogging.error("{}: {}".format(feedback.__class__.__name__,
str(feedback)))
sys.exit(2)
# part 3 - do the job
try:
engine.do(args.action, args.blueprints, args.facilities)
plogging.info(engine.document_elapsed())
except Exception as feedback:
if plogging.getEffectiveLevel() == logging.DEBUG:
plogging.error("Unable to do '{}'".format(args.action))
raise
else:
plogging.error("Unable to do '{}', run with -d for debug".format(
args.action))
plogging.error("{}: {}".format(feedback.__class__.__name__,
str(feedback)))
sys.exit(1)
def test_lifecycle(self):
engine = PlumberyEngine()
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
engine.do('build')
engine.build_all_blueprints()
engine.do('build', 'myBlueprint')
engine.build_blueprint('myBlueprint')
engine.do('deploy')
engine.do('deploy', 'myBlueprint')
engine.do('destroy')
engine.destroy_all_blueprints()
engine.do('destroy', 'myBlueprint')
engine.destroy_blueprint('myBlueprint')
engine.do('dispose')
engine.do('dispose', 'myBlueprint')
engine.do('polish')
engine.polish_all_blueprints()
engine.do('polish', 'myBlueprint')
engine.polish_blueprint('myBlueprint')
engine.do('secrets')
engine.do('start')
engine.start_all_blueprints()
engine.do('start', 'myBlueprint')
engine.start_blueprint('myBlueprint')
engine.do('stop')
engine.stop_all_blueprints()
engine.do('stop', 'myBlueprint')
engine.stop_blueprint('myBlueprint')
engine.do('wipe')
engine.wipe_all_blueprints()
engine.do('wipe', 'myBlueprint')
engine.wipe_blueprint('myBlueprint')
banner = engine.document_elapsed()
self.assertEqual('Worked for you' in banner, True)
def test_settings_private(self):
engine = PlumberyEngine()
engine.set_shared_secret('fake_secret')
engine.set_user_name('fake_name')
engine.set_user_password('fake_password')
engine.set_fittings(myPrivatePlan)
facilities = engine.list_facility('quasimoto.com')
self.assertEqual(len(facilities), 1)
facilities[0].power_on()
def test_get_default(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
infrastructure = PlumberyInfrastructure(facility)
self.assertEqual(infrastructure.get_default('ipv4'), 'auto')
def test_set(self):
engine = PlumberyEngine()
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
settings = {
'safeMode': False,
'polishers': [
{
'ansible': {}
},
{
'configure': {}
},
]
}
engine.set_settings(settings)
self.assertEqual(engine.safeMode, False)
engine.add_facility(myFacility)
self.assertEqual(len(engine.facilities), 1)
self.assertEqual(engine.get_shared_user(), 'root')
engine.set_shared_user('ubuntu')
self.assertEqual(engine.get_shared_user(), 'ubuntu')
engine.set_shared_secret('fake_secret')
self.assertEqual(engine.get_shared_secret(), 'fake_secret')
random = engine.get_secret('random')
self.assertEqual(len(random), 9)
self.assertEqual(engine.get_secret('random'), random)
engine.set_user_name('fake_name')
self.assertEqual(engine.get_user_name(), 'fake_name')
engine.set_user_password('fake_password')
self.assertEqual(engine.get_user_password(), 'fake_password')
from plumbery.engine import PlumberyEngine
engine = PlumberyEngine('fittings.yaml')
engine.build_blueprint('docker')
engine.start_blueprint('docker')
engine.polish_blueprint('docker', 'rub')
def test_param_http(self):
engine = PlumberyEngine()
with self.assertRaises(TypeError):
engine.set_parameters(('http://smee.com/params.yml'))
from plumbery.engine import PlumberyEngine
engine = PlumberyEngine('fittings.yaml')
engine.stop_blueprint('web')
engine.destroy_blueprint('web')
def test_remote_params(self):
engine = PlumberyEngine()
with requests_mock.mock() as m:
m.get('http://smee.com/params.yml', text=yaml.dump(myParameters))
engine.set_parameters('http://smee.com/params.yml')
class TestPlumberyFacility(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.plumbery.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
self.facility = PlumberyFacility(
plumbery=self.plumbery, fittings=fakeFittings)
self.facility.power_on()
def tearDown(self):
self.facility = None
def test_get_location_id(self):
self.assertEqual(self.facility.get_location_id(), 'NA9')
def test_list_basement(self):
self.assertEqual(self.facility.list_basement(), ['fake1'])
def test_list_blueprints(self):
self.assertEqual(self.facility.list_blueprints(), ['fake1', 'fake2'])
def test_expand_blueprint(self):
self.assertEqual(
self.facility.expand_blueprint('fake1'), ['fake1'])
self.assertEqual(
self.facility.expand_blueprint('fake1 unknown fake'), ['fake1'])
self.assertEqual(
self.facility.expand_blueprint('macro'), ['fake2'])
self.assertEqual(
self.facility.expand_blueprint('basement'), ['fake1'])
def test_get_blueprint(self):
self.assertEqual(
self.facility.get_blueprint('fake2')['target'], 'fake2')
self.assertIsNone(self.facility.get_blueprint('macro'))
self.assertIsNone(self.facility.get_blueprint('crazyAndunknown'))
def test_list_domains(self):
self.assertEqual(self.facility.list_domains(), ['VDC1'])
def test_list_ethernets(self):
self.assertEqual(self.facility.list_ethernets(), ['vlan1'])
def test_list_nodes(self):
self.assertEqual(self.facility.list_nodes(),
['stackstorm1', 'stackstorm2'])
def test_get_image(self):
self.assertRegexpMatches(
self.facility.get_image().name, "^RedHat ")
self.assertIsNone(self.facility.get_image('perfectlyUnknown'))
def test_focus(self):
self.facility.focus()
def test_process_all_blueprints(self):
action = FakeAction({})
self.facility.process_all_blueprints(action)
self.assertEqual(action.count, 14)
def test_process_blueprint(self):
action = FakeAction({})
self.facility.process_blueprint(action, names='fake')
self.assertEqual(action.count, 4)
def test_build_all_blueprints(self):
self.facility.build_all_blueprints()
def test_build_blueprint(self):
self.facility.build_blueprint('fake')
def test_start_all_blueprints(self):
self.facility.start_all_blueprints()
def test_start_blueprint(self):
self.facility.start_blueprint('fake')
def test_polish_all_blueprints(self):
self.facility.polish_all_blueprints(polishers='ping')
def test_polish_blueprint(self):
self.facility.polish_blueprint(names='fake', polishers='ping')
def test_stop_all_blueprints(self):
self.facility.stop_all_blueprints()
def test_stop_blueprint(self):
self.facility.stop_blueprint('fake')
def test_wipe_all_blueprints(self):
self.facility.wipe_all_blueprints()
def test_wipe_blueprint(self):
self.facility.wipe_blueprint('fake')
def test_destroy_all_blueprints(self):
self.facility.destroy_all_blueprints()
def test_destroy_blueprint(self):
self.facility.destroy_blueprint('fake')
def test_lookup(self):
self.assertEqual(self.facility.lookup('location.country'), 'US')
self.assertEqual(self.facility.lookup('location.id'), 'NA9')
self.assertEqual(self.facility.lookup('*unknown*'), None)
def test_settings(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
self.assertEqual(facility.get_setting('locationId'), 'EU6')
self.assertEqual(facility.get_setting('regionId'), 'dd-eu')
self.assertEqual(facility.get_setting('prepare'), None)
self.assertEqual(facility.get_setting('basement'), 'myBlueprint')
def test_settings_private(self):
settings = {
'apiHost': 'smee.com',
'locationId': 'NA5',
'safeMode': True
}
engine = PlumberyEngine(plan=settings)
engine.set_user_name('smee')
engine.set_user_password('smee')
facility = engine.list_facility()[0]
# facility.power_on()
self.assertEqual(facility.get_setting('locationId'), 'NA5')
self.assertIsNone(facility.get_setting('regionId'))
def test_blueprints(self):
engine = PlumberyEngine(defaultsPlan)
facility = engine.list_facility('EU6')[0]
blueprint = facility.get_blueprint('myBlueprint')
self.assertEqual(isinstance(blueprint, dict), True)
self.assertEqual(blueprint['domain']['name'], 'myDC')
self.assertEqual(blueprint['domain']['ipv4'], 'auto')
self.assertEqual(blueprint['ethernet']['name'], 'myVLAN')
self.assertEqual(blueprint['ethernet']['subnet'], '10.1.10.0')
self.assertEqual(len(blueprint['ethernet']['accept']), 1)
label = list(blueprint['nodes'][0])[0]
node = blueprint['nodes'][0][label]
self.assertEqual('default' not in node, True)
self.assertEqual(node['cpu'], 3)
self.assertEqual(node['memory'], 5)
self.assertEqual(len(node['information']), 2)
config = node['cloud-config']
self.assertEqual(isinstance(config, dict), True)
self.assertEqual(config['disable_root'], True)
self.assertEqual(config['ssh_pwauth'], True)
self.assertEqual(len(config['packages']), 4)
self.assertEqual(len(config['runcmd']), 4)
def test_environment(self):
engine = PlumberyEngine()
self.assertTrue(len(engine.lookup('environment.PATH')) > 0)
with self.assertRaises(KeyError):
engine.lookup('environment.PERFECTLY_UNKNOWN_FROM_HERE')
class MonitoringConfigurationTests(unittest.TestCase):
def setUp(self):
self.plumbery = PlumberyEngine()
self.plumbery.set_user_name('fake_user')
self.plumbery.set_user_password('fake_password')
DimensionDataNodeDriver.connectionCls.conn_classes = (
None, DimensionDataMockHttp)
DimensionDataMockHttp.type = None
self.plumbery.region = DimensionDataNodeDriver(*DIMENSIONDATA_PARAMS)
self.facility = PlumberyFacility(plumbery=self.plumbery,
fittings=myFacility)
self.facility.power_on()
def test_monitoring_validation_valid(self):
settings = {'monitoring': 'essentials'}
config = monitoring.MonitoringConfiguration(engine=None, facility=None)
self.assertTrue(config.validate(settings))
def test_monitoring_validation_invalid(self):
settings = {'monitoring': 'potato'}
config = monitoring.MonitoringConfiguration(engine=None, facility=None)
with self.assertRaises(ConfigurationError):
config.validate(settings)
def test_monitoring_configuration(self):
settings = {
'monitoring': 'essentials',
}
config = monitoring.MonitoringConfiguration(engine=None, facility=None)
node = TestNode()
config._start_monitoring = MagicMock(return_value=True)
config.configure(node, settings)
self.assertTrue(config)
config._start_monitoring.assert_called_with(node, 'ESSENTIALS')
def test_monitoring_configuration_deep(self):
settings = {
'monitoring': 'essentials',
}
config = monitoring.MonitoringConfiguration(engine=self.plumbery,
facility=self.facility)
node = TestNode()
config.configure(node, settings)
self.assertTrue(config)
def test_monitoring_deconfiguration(self):
settings = {
'monitoring': 'essentials',
}
config = monitoring.MonitoringConfiguration(engine=None, facility=None)
node = TestNode()
config._stop_monitoring = MagicMock(return_value=True)
config.deconfigure(node, settings)
self.assertTrue(config)
config._stop_monitoring.assert_called_with(node, settings)
def test_monitoring_deconfiguration_deep(self):
settings = {
'monitoring': 'essentials',
}
config = monitoring.MonitoringConfiguration(engine=self.plumbery,
facility=self.facility)
node = TestNode()
config.deconfigure(node, settings)
self.assertTrue(config)
def test_param_http(self):
engine = PlumberyEngine()
with self.assertRaises(TypeError):
engine.set_parameters(('http://smee.com/params.yml'))
