def setUp(self):
super(DesignateDriverTest, self).setUp()
self.domains = [
Domain(name='www.example.com',
id='11111111-1111-1111-1111-111111111111',
email='*****@*****.**'),
Domain(name='www.trove.com',
id='22222222-2222-2222-2222-222222222222',
email='*****@*****.**'),
Domain(name='www.openstack.com',
id='33333333-3333-3333-3333-333333333333',
email='*****@*****.**')
]
self.records = [
Record(name='record1',
type='A',
data='10.0.0.1',
ttl=3600,
priority=1),
Record(name='record2',
type='CNAME',
data='10.0.0.2',
ttl=1800,
priority=2),
Record(name='record3',
type='A',
data='10.0.0.3',
ttl=3600,
priority=1)
]
self.create_des_client_patch = patch.object(
driver, 'create_designate_client', MagicMock(return_value=None))
self.create_des_client_mock = self.create_des_client_patch.start()
self.addCleanup(self.create_des_client_patch.stop)
def execute(self, parsed_args):
domain_id = self.find_resourceid_by_name_or_id(
'domains', parsed_args.domain_id)
if not parsed_args.name.endswith('.'):
# Relative name?
domain_name = self.client.domains.get(domain_id)['name']
absolute = parsed_args.name + '.'
relative = absolute + domain_name
if absolute.endswith('.' + domain_name):
# Relative name or absolute name missing final period?
msg = ('"%s" is a relative name but looks like an absolute '
'name, use --name "%s" or "%s"'
% (parsed_args.name, absolute, relative))
raise ValueError(msg)
parsed_args.name = relative
record = Record(
name=parsed_args.name,
type=parsed_args.type,
data=parsed_args.data,
)
if parsed_args.ttl is not None:
record.ttl = parsed_args.ttl
if parsed_args.priority is not None:
record.priority = parsed_args.priority
if parsed_args.description:
record.description = parsed_args.description
return self.client.records.create(domain_id, record)
def execute(self, parsed_args):
domain_id = self.find_resourceid_by_name_or_id('domains',
parsed_args.domain_id)
if not parsed_args.name.endswith('.'):
# Relative name?
domain_name = self.client.domains.get(domain_id)['name']
absolute = parsed_args.name + '.'
relative = absolute + domain_name
if absolute.endswith('.' + domain_name):
# Relative name or absolute name missing final period?
msg = ('"%s" is a relative name but looks like an absolute '
'name, use --name "%s" or "%s"' %
(parsed_args.name, absolute, relative))
raise ValueError(msg)
parsed_args.name = relative
record = Record(
name=parsed_args.name,
type=parsed_args.type,
data=parsed_args.data,
)
if parsed_args.ttl is not None:
record.ttl = parsed_args.ttl
if parsed_args.priority:
record.priority = parsed_args.priority
if parsed_args.description:
record.description = parsed_args.description
return self.client.records.create(domain_id, record)
def setUp(self):
super(DesignateDriverTest, self).setUp()
self.domains = [
Domain(name='www.example.com',
id='11111111-1111-1111-1111-111111111111',
email='*****@*****.**'),
Domain(name='www.trove.com',
id='22222222-2222-2222-2222-222222222222',
email='*****@*****.**'),
Domain(name='www.openstack.com',
id='33333333-3333-3333-3333-333333333333',
email='*****@*****.**')
]
self.records = [
Record(name='record1',
type='A',
data='10.0.0.1',
ttl=3600,
priority=1),
Record(name='record2',
type='CNAME',
data='10.0.0.2',
ttl=1800,
priority=2),
Record(name='record3',
type='A',
data='10.0.0.3',
ttl=3600,
priority=1)
]
def execute(self, parsed_args):
record = Record(
name=parsed_args.name,
type=parsed_args.type,
data=parsed_args.data,
)
if parsed_args.ttl:
record.ttl = parsed_args.ttl
if parsed_args.priority:
record.priority = parsed_args.priority
return self.client.records.create(parsed_args.domain_id, record)
def test_convert_record_to_entry(self):
name = 'test.example.com'
id = '4f3439ef-fc8b-4098-a1aa-a66ed01102b9'
domain_id = '39413651-3b9e-41f1-a4df-e47d5e9f67be'
domain_name = 'example.com'
type = 'CNAME'
data = '127.0.0.1'
ttl = 3600
priority = 1
zone = driver.DesignateDnsZone(domain_id, domain_name)
record = Record(name=name,
id=id,
domain_id=domain_id,
type=type,
data=data,
priority=priority,
ttl=ttl)
converter = driver.DesignateObjectConverter()
converted_record = converter.record_to_entry(record, zone)
self.assertEqual(name, converted_record.name)
self.assertEqual(data, converted_record.content)
self.assertEqual(type, converted_record.type)
self.assertEqual(priority, converted_record.priority)
self.assertEqual(ttl, converted_record.ttl)
self.assertEqual(zone, converted_record.dns_zone)
def record_create(request, domain_id, **kwargs):
d_client = designateclient(request)
if d_client is None:
return []
record = Record(**kwargs)
return d_client.records.create(domain_id, record)
def execute(self, parsed_args):
record = Record(
name=parsed_args.name,
type=parsed_args.type,
data=parsed_args.data,
)
if parsed_args.ttl:
record.ttl = parsed_args.ttl
if parsed_args.priority:
record.priority = parsed_args.priority
if parsed_args.description:
record.description = parsed_args.description
return self.client.records.create(parsed_args.domain_id, record)
def create_entry(self, entry, content):
"""Creates the entry in the driver at the given dns zone."""
dns_zone = entry.dns_zone or self.default_dns_zone
if not dns_zone.id:
raise TypeError("The entry's dns_zone must have an ID specified.")
name = entry.name
LOG.debug("Creating DNS entry %s." % name)
client = self.dns_client
# Record name has to end with a '.' by dns standard
record = Record(name=entry.name + '.',
type=entry.type,
data=content,
ttl=entry.ttl,
priority=entry.priority)
client.records.create(dns_zone.id, record)
def record_update(request, domain_id, record_id, **kwargs):
d_client = designateclient(request)
if d_client is None:
return []
# A quirk of the designate client is that you need to start with a
# base record and then update individual fields in order to persist
# the data. The designate client will only send the 'changed' fields.
record = Record(id=record_id, type='A', name='', data='')
record.type = kwargs.get('type', None)
record.name = kwargs.get('name', None)
record.data = kwargs.get('data', None)
record.priority = kwargs.get('priority', None)
record.ttl = kwargs.get('ttl', None)
record.description = kwargs.get('description', None)
return d_client.records.update(domain_id, record)
def record(request, domain_id='', record_id=''):
client = Client(
auth_url="http://keystone:5000/v2.0/",
username="******",
password="******",
tenant_name="service",
endpoint="http://designate:9001/v1"
)
if request.method == "GET":
print(domain_id)
print(record_id)
if record_id:
try:
return HttpResponse(change_response(client.records.get(domain_id, record_id)))
except:
return HttpResponse("Not found", status=404)
else:
return HttpResponse(change_response(client.records.list(domain_id)))
elif request.method == "POST":
if 'priority' not in request.POST:
defined_priority = None
else:
defined_priority = int(request.POST['priority'])
if 'ttl' not in request.POST:
defined_ttl = 3600
else:
defined_ttl = int(request.POST['ttl'])
if 'description' not in request.POST:
defined_description = None
else:
defined_description = request.POST['description']
record = Record(name=request.POST['name'], type=request.POST['type'], data=request.POST['data'], priority=defined_priority, ttl=defined_ttl, description=defined_description)
return HttpResponse(change_response(client.records.create(domain_id, record)))
elif request.method == "PUT":
params = QueryDict(request.body, encoding=request._encoding)
record = client.records.get(domain_id, record_id)
if 'name' in params:
record.name = params['name']
if 'type' in params:
record.type = params['type']
if 'data' in params:
record.data = params['data']
if 'priority' in params:
record.priority = int(params['priority'])
if 'ttl' in params:
record.ttl = int(params['ttl'])
if 'description' in params:
domain.description = params['description']
return HttpResponse(change_response(client.records.update(domain_id, record)))
elif request.method == "DELETE":
client.records.delete(domain_id, record_id)
return HttpResponse("OK", status=200)
def record_update(request, domain_id, record_id, **kwargs):
d_client = designateclient(request)
if d_client is None:
return []
# A quirk of the designate client is that you need to start with a
# base record and then update individual fields in order to persist
# the data. The designate client will only send the 'changed' fields.
record = Record(
id=record_id,
type='A',
name='',
data='')
record.type = kwargs.get('type', None)
record.name = kwargs.get('name', None)
record.data = kwargs.get('data', None)
record.priority = kwargs.get('priority', None)
record.ttl = kwargs.get('ttl', None)
record.description = kwargs.get('description', None)
return d_client.records.update(domain_id, record)
def main(argv):
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument('-r',
'--resolver',
help='Resolver address. '
'Usually designate-bind address.',
required=False)
parser.add_argument('-d',
'--domain_name',
help='DNS Domain Name. '
'Must end in a .',
default='mojo.serverstack.')
parser.add_argument('-e',
'--email',
help='Email address',
default='*****@*****.**')
parser.add_argument('-b',
'--bind-service',
help='Bind Service Name',
default='designate-bind')
options = parser.parse_args()
bind_service_name = cli_utils.parse_arg(options, 'bind_service')
resolver = cli_utils.parse_arg(options, 'resolver')
bind_unit = mojo_utils.get_juju_units(bind_service_name)[0]
if not resolver:
resolver = mojo_utils.get_juju_unit_ip(bind_unit)
domain_name = cli_utils.parse_arg(options, 'domain_name')
email = cli_utils.parse_arg(options, 'email')
nameserver = 'ns1.{}'.format(domain_name)
logging.info('Setting up designate {} {}'.format(nameserver, resolver))
os_version = openstack_utils.get_current_os_versions(
'keystone')['keystone']
try:
cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'), 'cacert.pem')
os.stat(cacert)
except FileNotFoundError:
cacert = None
keystone_session = openstack_utils.get_overcloud_keystone_session(
verify=cacert)
neutronc = openstack_utils.get_neutron_session_client(keystone_session)
if os_version >= 'queens':
designatec = mojo_os_utils.get_designate_session_client(
keystone_session, client_version='2')
zone = mojo_os_utils.create_or_return_zone(designatec, domain_name,
email)
mojo_os_utils.create_or_return_recordset(designatec, zone['id'], 'www',
'A', [resolver])
else:
designatec = mojo_os_utils.get_designate_session_client(
keystone_session, client_version='1')
if not mojo_os_utils.get_designate_server_id(designatec, nameserver):
logging.info('Creating server {}'.format(nameserver))
server = Server(name=nameserver)
server_id = designatec.servers.create(server)
assert (server_id is not None)
else:
logging.info('{} server already exists.'.format(nameserver))
domain_id = mojo_os_utils.get_designate_domain_id(
designatec, domain_name)
if not domain_id:
logging.info('Creating domain {}'.format(domain_name))
domain = Domain(name=domain_name, email=email)
domain_id = designatec.domains.create(domain)
assert (domain_id is not None)
else:
logging.info('{} domain already exists.'.format(domain_name))
if not mojo_os_utils.get_designate_record_id(designatec, domain_id,
nameserver):
logging.info('Creating NS record {}'.format(nameserver))
ns_record = Record(name=nameserver, type="A", data=resolver)
record_id = designatec.records.create(domain_id, ns_record)
assert (record_id is not None)
else:
logging.info('{} record already exists.'.format(nameserver))
logging.info('Update network to use domain {}'.format(domain_name))
net_uuid = openstack_utils.get_net_uuid(neutronc, 'private')
mojo_os_utils.update_network_dns(neutronc, net_uuid, domain_name)
def handle(self, request, data):
proxyip = socket.gethostbyname(
urlparse.urlparse(base.url_for(request, 'proxy')).hostname)
if data.get('domain') == 'wmflabs.org.':
auth = identity_generic.Password(
auth_url=base.url_for(request, 'identity'),
username=getattr(settings, "WMFLABSDOTORG_ADMIN_USERNAME", ''),
password=getattr(settings, "WMFLABSDOTORG_ADMIN_PASSWORD", ''),
tenant_name='wmflabsdotorg',
user_domain_id='default',
project_domain_id='default')
c = designateclientv2.Client(session=keystone_session.Session(
auth=auth))
LOG.warn('Got create client')
# Create the record in the wmflabsdotorg project. This is needed
# since wmflabs.org lives in that project and designate prevents
# subdomain creation elsewhere.
zoneid = None
for zone in c.zones.list():
if zone['name'] == 'wmflabs.org.':
zoneid = zone['id']
break
else:
raise Exception("No zone ID")
LOG.warn('Got zone ID')
c.recordsets.create(zoneid,
data.get('record') + '.wmflabs.org.', 'A',
[proxyip])
else:
# TODO: Move this to designate v2 API, reuse some code
c = designateapi.designateclient(request)
domainid = None
for domain in c.domains.list():
if domain.name == data.get('domain'):
domainid = domain.id
break
else:
raise Exception("No domain ID")
record = Record(name=data.get('record') + '.' + data.get('domain'),
type='A',
data=proxyip)
c.records.create(domainid, record)
d = {
"backends": [
'http://%s:%s' %
(data.get('backendInstance'), data.get('backendPort'))
],
"domain":
data.get('record') + '.' + data.get('domain').rstrip('.')
}
try:
resp = requests.put(base.url_for(request, 'proxy') + '/mapping',
data=json.dumps(d))
if resp:
return True
else:
raise Exception("Got status: " + resp.status_code)
except Exception:
exceptions.handle(self.request,
_("Unable to create proxy: " + resp.text))
return False
def main(argv):
mojo_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument('-r', '--resolver',
help='Resolver address. '
'Usually designate-bind address.',
required=False)
parser.add_argument('-d', '--domain_name', help='DNS Domain Name. '
'Must end in a .',
default='mojo.serverstack.')
parser.add_argument('-e', '--email', help='Email address',
default='*****@*****.**')
parser.add_argument('-b', '--bind-service', help='Bind Service Name',
default='designate-bind')
options = parser.parse_args()
bind_service_name = mojo_utils.parse_mojo_arg(options, 'bind_service')
resolver = mojo_utils.parse_mojo_arg(options, 'resolver')
bind_unit = mojo_utils.get_juju_units(service=bind_service_name)[0]
if not resolver:
resolver = mojo_utils.get_juju_unit_ip(bind_unit)
domain_name = mojo_utils.parse_mojo_arg(options, 'domain_name')
email = mojo_utils.parse_mojo_arg(options, 'email')
nameserver = 'ns1.{}'.format(domain_name)
logging.info('Setting up designate {} {}'.format(nameserver, resolver))
overcloud_novarc = mojo_utils.get_overcloud_auth()
os_version = mojo_os_utils.get_current_os_versions('keystone')['keystone']
# Keystone policy.json shipped the charm with liberty requires a domain
# scoped token. Bug #1649106
if os_version == 'liberty':
scope = 'DOMAIN'
else:
scope = 'PROJECT'
keystone_session = mojo_os_utils.get_keystone_session(overcloud_novarc,
scope=scope)
neutronc = mojo_os_utils.get_neutron_session_client(keystone_session)
if os_version >= 'queens':
designatec = mojo_os_utils.get_designate_session_client(
keystone_session,
client_version='2')
zone = mojo_os_utils.create_or_return_zone(
designatec,
domain_name,
email)
rs = mojo_os_utils.create_or_return_recordset(
designatec,
zone['id'],
'www',
'A',
[resolver])
else:
designatec = mojo_os_utils.get_designate_session_client(
keystone_session,
client_version='1')
if not mojo_os_utils.get_designate_server_id(designatec, nameserver):
logging.info('Creating server {}'.format(nameserver))
server = Server(name=nameserver)
server_id = designatec.servers.create(server)
assert(server_id is not None)
else:
logging.info('{} server already exists.'.format(nameserver))
domain_id = mojo_os_utils.get_designate_domain_id(
designatec,
domain_name)
if not domain_id:
logging.info('Creating domain {}'.format(domain_name))
domain = Domain(name=domain_name, email=email)
domain_id = designatec.domains.create(domain)
assert(domain_id is not None)
else:
logging.info('{} domain already exists.'.format(domain_name))
if not mojo_os_utils.get_designate_record_id(designatec, domain_id,
nameserver):
logging.info('Creating NS record {}'.format(nameserver))
ns_record = Record(
name=nameserver,
type="A",
data=resolver)
record_id = designatec.records.create(domain_id, ns_record)
assert(record_id is not None)
else:
logging.info('{} record already exists.'.format(nameserver))
logging.info('Update network to use domain {}'.format(domain_name))
net_uuid = mojo_os_utils.get_net_uuid(neutronc, 'private')
mojo_os_utils.update_network_dns(neutronc, net_uuid, domain_name)
