def main(config_file):
manager = Manager(config_file)
for zone_name, config in manager.config['zones'].items():
zone = Zone(zone_name, manager.configured_sub_zones(zone_name))
try:
sources = config['sources']
except KeyError:
raise Exception('Zone {} is missing sources'.format(zone_name))
try:
sources = [manager.providers[source] for source in sources]
except KeyError:
raise Exception('Zone {}, unknown source: {}'.format(
zone_name, source))
for source in sources:
if isinstance(source, YamlProvider):
source.populate(zone)
pages_sites = [
record for record in zone.records
if isinstance(record, CnameRecord)
and record.value.endswith("github.io.")
]
for record in pages_sites:
validate_github_pages_site(record)
def _dump_current_dns_records(self, task: TaskView, folder: WorkFolder):
task.logger.debug("OctoDNS configurator - downloading current DNS records")
path = folder.cwd
zone_name = _get_zone(task.vars["SELF"]["name"])
with change_cwd(path, task.logger):
manager = Manager(config_file="main-config.yaml")
zone = Zone(zone_name, manager.configured_sub_zones(zone_name))
exists = manager.providers["target_config"].populate(zone, lenient=True)
if not exists:
return {}
# now the zone.records has the latest records as a set
# copied from https://github.com/octodns/octodns/blob/f6629f1ce49919d523f7d26eb14e9125348a3059/octodns/provider/yaml.py#L160
# Order things alphabetically (records sort that way
records = list(zone.records)
records.sort()
data = defaultdict(list)
for record in records:
d = record.data
d["type"] = record._type
if record.ttl == manager.providers["source_config"].default_ttl:
# ttl is the default, we don't need to store it
del d["ttl"]
if record._octodns:
d["octodns"] = record._octodns
data[record.name].append(sort_dict(d))
# Flatten single element lists
for k in data.keys():
if len(data[k]) == 1:
data[k] = data[k][0]
return sort_dict(data)
def main():
"""check-zone based on octodns config file and dns zone
Will query all 4 DNS servers configured for the zone in GCP.
"""
parser = ArgumentParser(description=__doc__.split('\n')[1])
parser.add_argument('--config-file', required=True,
help='The OctoDNS configuration file to use')
parser.add_argument('--zone', action='append', required=True, help='zone to check')
args = parser.parse_args()
manager = Manager(args.config_file)
for zone_name in args.zone:
print('Checking records for {}'.format(zone_name))
zone = Zone(zone_name, manager.configured_sub_zones(zone_name))
# Read our YAML configuration
yaml_config = manager.providers['config']
# Build a GCP provider in our project to read the nameservers from it
gcp = manager.providers['gcp']
project = gcp.gcloud_client.project
# Retrieve the DNS Servers directly from the GCP configuration
dns_servers = gcp.gcloud_zones[zone_name].name_servers
# k8s.io resolvers for testing without access to gcp
#dns_servers = ["NS-CLOUD-D1.GOOGLEDOMAINS.COM", "NS-CLOUD-D2.GOOGLEDOMAINS.COM", "NS-CLOUD-D3.GOOGLEDOMAINS.COM", "NS-CLOUD-D4.GOOGLEDOMAINS.COM"]
print('Using GCP project {}'.format(project))
print('name,type,ttl,{},consistent'.format(','.join(dns_servers)))
# Populate the zone with those records defined in our YAML config
yaml_config.populate(zone)
# This would populate the zone with records already defined in Google Cloud DNS
# gcp.populate(zone)
# Configure Resolvers (one per DNS server)
resolvers = configure_resolvers(dns_servers)
# Populate the queries to make based on zone record configuration
queries = {}
for record in sorted(zone.records):
queries[record] = [r.query(record.fqdn, record._type)
for r in resolvers]
# No dns_error unless we find one
dns_error = False
dns_error = verify_dns(queries)
if dns_error:
sys.exit(1)
sys.exit(0)
def main():
"""check-zone based on octodns config file and dns zone
Will query all 4 DNS servers configured for the zone in GCP.
"""
parser = ArgumentParser(description=__doc__.split('\n')[1])
parser.add_argument('--config-file',
required=True,
help='The OctoDNS configuration file to use')
parser.add_argument('--zone',
action='append',
required=True,
help='zone to check')
args = parser.parse_args()
manager = Manager(args.config_file)
for zone_name in args.zone:
print('Checking records for {}'.format(zone_name))
zone = Zone(zone_name, manager.configured_sub_zones(zone_name))
gcp = manager.providers['gcp']
project = gcp.gcloud_client.project
gcp.populate(zone)
# Retrieve the DNS Servers directly from the GCP configuration
dns_servers = gcp.gcloud_zones[zone_name].name_servers
print('Using GCP project {}'.format(project))
print('name,type,ttl,{},consistent'.format(','.join(dns_servers)))
# Configure Resolvers (one per DNS server)
resolvers = configure_resolvers(dns_servers)
# Populate the queries to make based on zone record configuration
queries = {}
for record in sorted(zone.records):
queries[record] = [
r.query(record.fqdn, record._type) for r in resolvers
]
# No dns_error unless we find one
dns_error = False
dns_error = verify_dns(queries)
if dns_error:
sys.exit(1)
sys.exit(0)
def main(config_file):
manager = Manager(config_file)
for zone_name, config in manager.config['zones'].items():
zone = Zone(zone_name, manager.configured_sub_zones(zone_name))
try:
sources = config['sources']
except KeyError:
raise Exception('Zone {} is missing sources'.format(zone_name))
try:
sources = [manager.providers[source] for source in sources]
except KeyError:
raise Exception('Zone {}, unknown source: {}'.format(
zone_name, source))
for source in sources:
if isinstance(source, YamlProvider):
source.populate(zone)
for record in zone.records:
print_record(record)
def main():
parser = ArgumentParser(description=__doc__.split('\n')[1])
parser.add_argument('--config-file', required=True,
help='The Manager configuration file to use')
parser.add_argument('--zone', required=True, help='Zone to dump')
parser.add_argument('--source', required=True, default=[], action='append',
help='Source(s) to pull data from')
parser.add_argument('--num-workers', default=4,
help='Number of background workers')
parser.add_argument('--timeout', default=1,
help='Number seconds to wait for an answer')
parser.add_argument('server', nargs='+', help='Servers to query')
args = parser.parse_args()
manager = Manager(args.config_file)
log = getLogger('report')
try:
sources = [manager.providers[source] for source in args.source]
except KeyError as e:
raise Exception('Unknown source: {}'.format(e.args[0]))
zone = Zone(args.zone, manager.configured_sub_zones(args.zone))
for source in sources:
source.populate(zone)
print('name,type,ttl,{},consistent'.format(','.join(args.server)))
resolvers = []
ip_addr_re = re.compile(r'^[\d\.]+$')
for server in args.server:
resolver = AsyncResolver(configure=False,
num_workers=int(args.num_workers))
if not ip_addr_re.match(server):
server = text_type(query(server, 'A')[0])
log.info('server=%s', server)
resolver.nameservers = [server]
resolver.lifetime = int(args.timeout)
resolvers.append(resolver)
queries = {}
for record in sorted(zone.records):
queries[record] = [r.query(record.fqdn, record._type)
for r in resolvers]
for record, futures in sorted(queries.items(), key=lambda d: d[0]):
stdout.write(record.fqdn)
stdout.write(',')
stdout.write(record._type)
stdout.write(',')
stdout.write(text_type(record.ttl))
compare = {}
for future in futures:
stdout.write(',')
try:
answers = [text_type(r) for r in future.result()]
except (NoAnswer, NoNameservers):
answers = ['*no answer*']
except NXDOMAIN:
answers = ['*does not exist*']
except Timeout:
answers = ['*timeout*']
stdout.write(' '.join(answers))
# sorting to ignore order
answers = '*:*'.join(sorted(answers)).lower()
compare[answers] = True
stdout.write(',True\n' if len(compare) == 1 else ',False\n')
