def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbalias = Alias.get_unique(session,
fqdn=fqdn,
dns_environment=dbdns_env,
compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger, target,
dbdns_env)
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
dbalias = Alias.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env, compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger,
target, dbdns_env)
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
def lookup_target(session, plenaries, hostname, ip, cluster, resourcegroup,
service_address, alias):
"""
Check the parameters of the server providing a given service
Look for potential conflicts, and return a dict that is suitable to be
passed to either the constructor of ServiceInstanceServer, or to the
find_server() function.
"""
params = {}
if cluster and hostname:
raise ArgumentError("Only one of --cluster and --hostname may be "
"specified.")
if alias:
dbdns_env = DnsEnvironment.get_unique_or_default(session)
dbdns_rec = Alias.get_unique(session, fqdn=alias,
dns_environment=dbdns_env, compel=True)
params["alias"] = dbdns_rec
if hostname:
params["host"] = hostname_to_host(session, hostname)
plenaries.append(Plenary.get_plenary(params["host"]))
if cluster:
params["cluster"] = Cluster.get_unique(session, cluster, compel=True)
plenaries.append(Plenary.get_plenary(params["cluster"]))
if service_address:
# TODO: calling get_resource_holder() means doing redundant DB lookups
# TODO: it would be nice to also accept an FQDN for the service address,
# to be consistent with the usage of the --service_address option in
# add_service_address/del_service_address
holder = get_resource_holder(session, hostname=hostname,
cluster=cluster,
resgroup=resourcegroup, compel=True)
dbsrv_addr = ServiceAddress.get_unique(session,
name=service_address,
holder=holder, compel=True)
params["service_address"] = dbsrv_addr
elif ip:
for addr in params["host"].hardware_entity.all_addresses():
if ip != addr.ip:
continue
if addr.service_address:
params["service_address"] = addr.service_address
else:
params["address_assignment"] = addr
break
return params
def render(self, session, logger, fqdn, dns_environment, **kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session, dns_environment)
dbdns_rec = Alias.get_unique(session, fqdn=fqdn, dns_environment=dbdns_env, compel=True)
domain = dbdns_rec.fqdn.dns_domain.name
old_target_fqdn = str(dbdns_rec.target)
old_comments = dbdns_rec.comments
target_is_restricted = dbdns_rec.target.dns_domain.restricted
delete_dns_record(dbdns_rec)
session.flush()
if dbdns_env.is_default and domain == "ms.com" and not target_is_restricted:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_alias(fqdn, old_target_fqdn, old_comments)
dsdb_runner.commit_or_rollback("Could not delete alias from DSDB")
return
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
dbalias = Alias.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env, compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger,
target, dbdns_env)
# TODO: at some day we should verify that the new target is also
# bound as a server, and modify the ServiceInstanceServer bindings
# accordingly
for srv in dbalias.services_provided:
if srv.host or srv.cluster:
provider = srv.host or srv.cluster
logger.client_info("Warning: {0} provides {1:l}, and is "
"bound to {2:l}. Updating the target of "
"the alias may leave that server "
"binding in an inconsistent state."
.format(dbalias, srv.service_instance,
provider))
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbfqdn = Fqdn.get_or_create(session,
dns_environment=dbdns_env,
fqdn=fqdn)
if dbfqdn.dns_domain.restricted:
raise ArgumentError(
"{0} is restricted, aliases are not allowed.".format(
dbfqdn.dns_domain))
DnsRecord.get_unique(session, fqdn=dbfqdn, preclude=True)
dbtarget = create_target_if_needed(session, logger, target, dbdns_env)
try:
db_record = Alias(fqdn=dbfqdn, target=dbtarget, comments=comments)
session.add(db_record)
except ValueError, err:
raise ArgumentError(err.message)
def render(self, session, logger, fqdn, dns_environment, **kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbdns_rec = Alias.get_unique(session,
fqdn=fqdn,
dns_environment=dbdns_env,
compel=True)
domain = dbdns_rec.fqdn.dns_domain.name
old_target_fqdn = str(dbdns_rec.target)
old_comments = dbdns_rec.comments
target_is_restricted = dbdns_rec.target.dns_domain.restricted
delete_dns_record(dbdns_rec)
session.flush()
if dbdns_env.is_default and domain == "ms.com" and not target_is_restricted:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_alias(fqdn, old_target_fqdn, old_comments)
dsdb_runner.commit_or_rollback("Could not delete alias from DSDB")
return