def stash_services(self):
changed_servers = set()
for instance in self.instances_bound.union(self.instances_unbound):
if not instance.service.need_client_list:
continue
for srv in instance.servers:
if srv.host:
changed_servers.add(srv.host)
if srv.cluster:
changed_servers.add(srv.cluster)
plenary = PlenaryServiceInstanceServer.get_plenary(instance)
self.plenaries.append(plenary)
for dbobj in changed_servers:
# Skip servers that do not have a profile
if not dbobj.personality.archetype.is_compileable:
continue
# Skip servers that are in a different domain/sandbox
if (dbobj.branch != self.dbobj.branch or
dbobj.sandbox_author_id != self.dbobj.sandbox_author_id):
continue
self.plenaries.append(Plenary.get_plenary(dbobj))
if isinstance(dbobj, Cluster):
for dbhost in dbobj.hosts:
self.plenaries.append(Plenary.get_plenary(dbhost))
def render(self, session, logger, hostname, service, **arguments):
dbhost = hostname_to_host(session, hostname)
for srv in dbhost.archetype.services + dbhost.personality.services:
if srv.name == service:
raise ArgumentError("Cannot unbind a required service. "
"Perhaps you want to rebind?")
dbservice = Service.get_unique(session, service, compel=True)
si = get_host_bound_service(dbhost, dbservice)
if si:
logger.info("Removing client binding")
dbhost.services_used.remove(si)
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbhost))
plenaries.append(PlenaryServiceInstanceServer.get_plenary(si))
plenaries.write()
return
def stash_services(self):
for instance in self.instances_bound.union(self.instances_unbound):
plenary = PlenaryServiceInstanceServer(instance,
logger=self.logger)
plenary.stash()
self.plenaries.append(plenary)
def stash_services(self):
for instance in self.instances_bound.union(self.instances_unbound):
plenary = PlenaryServiceInstanceServer(instance, logger=self.logger)
plenary.stash()
self.plenaries.append(plenary)
def render(self, session, logger, hostname, **arguments):
# Check dependencies, translate into user-friendly message
dbhost = hostname_to_host(session, hostname)
dbhost.lock_row()
check_no_provided_service(dbhost)
# Any service bindings that we need to clean up afterwards
plenaries = PlenaryCollection(logger=logger)
remove_plenaries = PlenaryCollection(logger=logger)
remove_plenaries.append(Plenary.get_plenary(dbhost))
archetype = dbhost.archetype.name
dbmachine = dbhost.hardware_entity
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
ip = dbmachine.primary_ip
for si in dbhost.services_used:
plenaries.append(PlenaryServiceInstanceServer.get_plenary(si))
logger.info("Before deleting {0:l}, removing binding to {1:l}"
.format(dbhost, si))
del dbhost.services_used[:]
if dbhost.resholder:
for res in dbhost.resholder.resources:
remove_plenaries.append(Plenary.get_plenary(res))
# In case of Zebra, the IP may be configured on multiple interfaces
for iface in dbmachine.interfaces:
if ip in iface.addresses:
iface.addresses.remove(ip)
if dbhost.cluster:
dbcluster = dbhost.cluster
dbcluster.hosts.remove(dbhost)
set_committed_value(dbhost, '_cluster', None)
dbcluster.validate()
plenaries.append(Plenary.get_plenary(dbcluster))
dbdns_rec = dbmachine.primary_name
dbmachine.primary_name = None
dbmachine.host = None
session.delete(dbhost)
delete_dns_record(dbdns_rec)
session.flush()
if dbmachine.vm_container:
plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
with CompileKey.merge([plenaries.get_key(),
remove_plenaries.get_key()]):
plenaries.stash()
remove_plenaries.stash()
try:
plenaries.write(locked=True)
remove_plenaries.remove(locked=True, remove_profile=True)
if archetype != 'aurora' and ip is not None:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not remove host %s from "
"DSDB" % hostname)
if archetype == 'aurora':
logger.client_info("WARNING: removing host %s from AQDB and "
"*not* changing DSDB." % hostname)
except:
plenaries.restore_stash()
remove_plenaries.restore_stash()
raise
trigger_notifications(self.config, logger, CLIENT_INFO)
return
