def polish_blueprint(self, names, polishers):
"""
Walks a named blueprint for this facility and polish related resources
:param names: the name(s) of the blueprint(s) to polish
:type names: ``str`` or ``list`` of ``str``
:param polishers: polishers to be applied
:type polishers: list of :class:`plumbery.PlumberyPolisher`
"""
if isinstance(polishers, str):
polishers = PlumberyPolisher.filter(self.plumbery.polishers,
polishers)
self.power_on()
infrastructure = PlumberyInfrastructure(self)
nodes = PlumberyNodes(self)
for polisher in polishers:
polisher.move_to(self)
for name in self.expand_blueprint(names):
blueprint = self.get_blueprint(name)
container = infrastructure.get_container(blueprint)
for polisher in polishers:
polisher.shine_container(container)
nodes.polish_blueprint(blueprint, polishers, container)
def destroy_all_blueprints(self):
"""
Destroys all blueprints at this facility
"""
self.power_on()
nodes = PlumberyNodes(self)
infrastructure = PlumberyInfrastructure(self)
basement = self.list_basement()
for name in self.expand_blueprint('*'):
if name in basement:
continue
blueprint = self.get_blueprint(name)
plogging.debug("Destroying blueprint '{}'".format(name))
nodes.destroy_blueprint(blueprint)
infrastructure.destroy_blueprint(blueprint)
for name in basement:
blueprint = self.get_blueprint(name)
plogging.debug("Destroying blueprint '{}'".format(name))
nodes.destroy_blueprint(blueprint)
infrastructure.destroy_blueprint(blueprint)
def build_blueprint(self, names):
"""
Builds a named blueprint for this facility
:param names: the name(s) of the blueprint(s) to build
:type names: ``str`` or ``list`` of ``str``
This function builds the named blueprint in two steps: the
infrastructure comes first, and then the nodes themselves.
>>>facility.build_blueprint('sql')
If the keyword ``basement`` mentions one or several blueprints,
then network domains of these special blueprints are built before
the actual target blueprint.
Example ``fittings.yaml``::
---
basement: admin
blueprints:
- admin:
ethernet: control
- sql:
ethernet: data
nodes:
- server1:
glue: control
In this example, the node ``server1``has two network interfaces. The
main network interface is connected to the network ``data``, and the
secondary network interface is connected to the network ``control``.
"""
self.power_on()
infrastructure = PlumberyInfrastructure(self)
nodes = PlumberyNodes(self)
basement = self.list_basement()
for name in basement:
blueprint = self.get_blueprint(name)
infrastructure.build(blueprint)
for name in self.expand_blueprint(names):
blueprint = self.get_blueprint(name)
if name not in basement:
infrastructure.build(blueprint)
nodes.build_blueprint(blueprint,
infrastructure.get_container(blueprint))
def destroy_blueprint(self, names):
"""
Destroys a given blueprint at this facility
:param names: the name(s) of the blueprint(s) to destroy
:type names: ``str`` or ``list`` of ``str``
"""
self.power_on()
nodes = PlumberyNodes(self)
infrastructure = PlumberyInfrastructure(self)
for name in self.expand_blueprint(names):
blueprint = self.get_blueprint(name)
nodes.destroy_blueprint(blueprint)
infrastructure.destroy_blueprint(blueprint)
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 build_all_blueprints(self):
"""
Builds all blueprints defined for this facility
This function builds all network domains across all blueprints, then
it builds all nodes across all blueprints.
If the keyword ``basement`` mentions one or several blueprints,
then these are built before the other blueprints.
"""
self.power_on()
infrastructure = PlumberyInfrastructure(self)
nodes = PlumberyNodes(self)
basement = self.list_basement()
for name in basement:
blueprint = self.get_blueprint(name)
infrastructure.build(blueprint)
blueprints = self.expand_blueprint('*')
for name in blueprints:
if name not in basement:
blueprint = self.get_blueprint(name)
infrastructure.build(blueprint)
for name in basement:
blueprint = self.get_blueprint(name)
container = infrastructure.get_container(blueprint)
nodes.build_blueprint(blueprint, container)
for name in blueprints:
if name not in basement:
blueprint = self.get_blueprint(name)
container = infrastructure.get_container(blueprint)
nodes.build_blueprint(blueprint, container)
def destroy_blueprint(self, blueprint):
"""
Destroys nodes of a given blueprint
:param blueprint: the blueprint to build
:type blueprint: ``dict``
"""
self.facility.power_on()
infrastructure = PlumberyInfrastructure(self.facility)
container = infrastructure.get_container(blueprint)
if ('nodes' not in blueprint
or not isinstance(blueprint['nodes'], list)):
return
# destroy in reverse order
for item in reversed(blueprint['nodes']):
if type(item) is dict:
label = list(item)[0]
settings = item[label]
else:
label = str(item)
settings = {}
for label in self.expand_labels(label):
node = self.get_node(label)
if node is None:
plogging.info("Destroying node '{}'".format(label))
plogging.info("- not found")
continue
if 'destroy' in settings and settings['destroy'] == 'never':
plogging.info("Destroying node '{}'".format(label))
plogging.info("- this node can never be destroyed")
return False
timeout = 300
tick = 6
while node.extra['status'].action == 'SHUTDOWN_SERVER':
time.sleep(tick)
node = self.get_node(label)
timeout -= tick
if timeout < 0:
break
if node.state == NodeState.RUNNING:
plogging.info("Destroying node '{}'".format(label))
plogging.info("- skipped - node is up and running")
continue
if self.plumbery.safeMode:
plogging.info("Destroying node '{}'".format(label))
plogging.info("- skipped - safe mode")
continue
configuration = MonitoringConfiguration(
engine=container.facility.plumbery,
facility=container.facility)
configuration.deconfigure(node, settings)
self._detach_node(node, settings)
container._detach_node_from_internet(node)
plogging.info("Destroying node '{}'".format(label))
while True:
try:
self.region.destroy_node(node)
plogging.info("- in progress")
except Exception as feedback:
if 'RESOURCE_BUSY' in str(feedback):
time.sleep(10)
continue
elif 'RESOURCE_NOT_FOUND' in str(feedback):
plogging.info("- not found")
elif 'SERVER_STARTED' in str(feedback):
plogging.info("- skipped - node is up and running")
elif 'RESOURCE_LOCKED' in str(feedback):
plogging.info("- not now - locked")
return False
else:
plogging.info("- unable to destroy node")
plogging.error(str(feedback))
break
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 setUp(self):
facility = FakeFacility()
self.infrastructure = PlumberyInfrastructure(facility=facility)