def post_all(self): """Create Blacklisted Zone""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict blacklist = DesignateAdapter.parse('API_v2', body, Blacklist()) blacklist.validate() # Create the blacklist blacklist = self.central_api.create_blacklist( context, blacklist) LOG.info("Created %(blacklist)s", {'blacklist': blacklist}) response.status_int = 201 blacklist = DesignateAdapter.render( 'API_v2', blacklist, request=request) response.headers['Location'] = blacklist['links']['self'] # Prepare and return the response body return blacklist
def post_all(self, zone_id): """Create ZoneTransferRequest""" request = pecan.request response = pecan.response context = request.environ['context'] try: body = request.body_dict except exceptions.EmptyRequestBody: body = dict() zone = self.central_api.get_zone(context, zone_id) body['zone_name'] = zone.name body['zone_id'] = zone_id zone_transfer_request = DesignateAdapter.parse( 'API_v2', body, ZoneTransferRequest()) zone_transfer_request.validate() # Create the zone_transfer_request zone_transfer_request = self.central_api.create_zone_transfer_request( context, zone_transfer_request) response.status_int = 201 LOG.info("Created %(zone_transfer_request)s", {'zone_transfer_request': zone_transfer_request}) zone_transfer_request = DesignateAdapter.render( 'API_v2', zone_transfer_request, request=request, context=context) response.headers['Location'] = zone_transfer_request['links']['self'] # Prepare and return the response body return zone_transfer_request
def patch_one(self, pool_id): """Update the specific pool""" LOG.warning(_LW("Use of this API Method is DEPRICATED. This will have " "unforseen side affects when used with the " "designate-manage pool commands")) request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing pool pool = self.central_api.get_pool(context, pool_id) pool = DesignateAdapter.parse('API_v2', body, pool) pool.validate() pool = self.central_api.update_pool(context, pool) LOG.info(_LI("Updated %(pool)s"), {'pool': pool}) response.status_int = 202 return DesignateAdapter.render('API_v2', pool, request=request)
def post_all(self): """Create ZoneTransferAccept""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict zone_transfer_accept = DesignateAdapter.parse( 'API_v2', body, ZoneTransferAccept()) zone_transfer_accept.validate() # Create the zone_transfer_request zone_transfer_accept = self.central_api.create_zone_transfer_accept( context, zone_transfer_accept) response.status_int = 201 LOG.info(_LI("Created %(zone_transfer_accept)s"), {'zone_transfer_accept': zone_transfer_accept}) zone_transfer_accept = DesignateAdapter.render( 'API_v2', zone_transfer_accept, request=request) response.headers['Location'] = zone_transfer_accept['links']['self'] # Prepare and return the response body return zone_transfer_accept
def patch_one(self, fip_key): """ Set or unset a PTR """ request = pecan.request response = pecan.response context = request.environ['context'] try: body = request.body_dict except Exception as e: if e.message != 'TODO: Unsupported Content Type': raise else: # Got a blank body body = dict() region, id_ = fip_key_to_data(fip_key) fip = DesignateAdapter.parse('API_v2', body, objects.FloatingIP()) fip.validate() fip = self.central_api.update_floatingip(context, region, id_, fip) response.status_int = 202 if fip: return DesignateAdapter.render('API_v2', fip, request=request)
def patch_one(self, zone_transfer_request_id): """Update ZoneTransferRequest""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing zone_transfer_request zone_transfer_request = self.central_api.get_zone_transfer_request( context, zone_transfer_request_id) zone_transfer_request = DesignateAdapter.parse( 'API_v2', body, zone_transfer_request) zone_transfer_request.validate() zone_transfer_request = self.central_api.update_zone_transfer_request( context, zone_transfer_request) response.status_int = 200 return DesignateAdapter.render( 'API_v2', zone_transfer_request, request=request, context=context)
def post_all(self, zone_id): """Create ZoneTransferRequest""" request = pecan.request response = pecan.response context = request.environ['context'] try: body = request.body_dict except Exception as e: if six.text_type(e) != 'TODO: Unsupported Content Type': raise else: # Got a blank body body = dict() body['zone_id'] = zone_id zone_transfer_request = DesignateAdapter.parse( 'API_v2', body, ZoneTransferRequest()) zone_transfer_request.validate() # Create the zone_transfer_request zone_transfer_request = self.central_api.create_zone_transfer_request( context, zone_transfer_request) response.status_int = 201 zone_transfer_request = DesignateAdapter.render( 'API_v2', zone_transfer_request, request=request, context=context) response.headers['Location'] = zone_transfer_request['links']['self'] # Prepare and return the response body return zone_transfer_request
def post_all(self): """Create a Pool""" LOG.warning(_LW("Use of this API Method is DEPRICATED. This will have " "unforseen side affects when used with the " "designate-manage pool commands")) request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict pool = DesignateAdapter.parse('API_v2', body, Pool()) pool.validate() # Create the pool pool = self.central_api.create_pool(context, pool) LOG.info(_LI("Created %(pool)s"), {'pool': pool}) pool = DesignateAdapter.render('API_v2', pool, request=request) response.status_int = 201 response.headers['Location'] = pool['links']['self'] # Prepare and return the response body return pool
def patch_one(self, tsigkey_id): """Update TsigKey""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing tsigkey entry tsigkey = self.central_api.get_tsigkey(context, tsigkey_id) tsigkey = DesignateAdapter.parse('API_v2', body, tsigkey) # Validate the new set of data tsigkey.validate() # Update and persist the resource tsigkey = self.central_api.update_tsigkey(context, tsigkey) LOG.info("Updated %(tsigkey)s", {'tsigkey': tsigkey}) response.status_int = 200 return DesignateAdapter.render('API_v2', tsigkey, request=request)
def post_all(self, zone_id): """Create RecordSet""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict recordset = DesignateAdapter.parse('API_v2', body, RecordSet()) recordset.validate() # SOA recordsets cannot be created manually if recordset.type == 'SOA': raise exceptions.BadRequest( "Creating a SOA recordset is not allowed") # Create the recordset recordset = self.central_api.create_recordset( context, zone_id, recordset) # Prepare the response headers if recordset['status'] == 'PENDING': response.status_int = 202 else: response.status_int = 201 recordset = DesignateAdapter.render( 'API_v2', recordset, request=request) response.headers['Location'] = recordset['links']['self'] # Prepare and return the response body return recordset
def patch_one(self, zone_id): """Update Zone""" # TODO(kiall): This needs cleanup to say the least.. request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response # TODO(kiall): Validate we have a sane UUID for zone_id # Fetch the existing zone zone = self.central_api.get_zone(context, zone_id) # Don't allow updates to zones that are being deleted if zone.action == "DELETE": raise exceptions.BadRequest('Can not update a deleting zone') if request.content_type == 'application/json-patch+json': # Possible pattern: # # 1) Load existing zone. # 2) Apply patch, maintain list of changes. # 3) Return changes, after passing through the code ^ for plain # JSON. # # Difficulties: # # 1) "Nested" resources? records inside a recordset. # 2) What to do when a zone doesn't exist in the first place? # 3) ...? raise NotImplemented('json-patch not implemented') else: # Update the zone object with the new values zone = DesignateAdapter.parse('API_v2', body, zone) zone.validate() # If masters are specified then we set zone.transferred_at to None # which will cause a new transfer if 'attributes' in zone.obj_what_changed(): zone.transferred_at = None # Update and persist the resource if zone.type == 'SECONDARY' and 'email' in zone.obj_what_changed(): msg = "Changed email is not allowed." raise exceptions.InvalidObject(msg) increment_serial = zone.type == 'PRIMARY' zone = self.central_api.update_zone( context, zone, increment_serial=increment_serial) LOG.info(_LI("Updated %(zone)s"), {'zone': zone}) if zone.status == 'PENDING': response.status_int = 202 else: response.status_int = 200 return DesignateAdapter.render('API_v2', zone, request=request)
def _handle_errors(self, request, exception): response = {} headers = [ ('Content-Type', 'application/json'), ] rendered_errors = DesignateAdapter.render( self.api_version, exception.errors, failed_object=exception.object) url = getattr(request, 'url', None) response['code'] = exception.error_code response['type'] = exception.error_type or 'unknown' response['errors'] = rendered_errors # Return the new response if 'context' in request.environ: response['request_id'] = request.environ['context'].request_id notifications.send_api_fault(request.environ['context'], url, response['code'], exception) else: # TODO(ekarlso): Remove after verifying that there's actually a # context always set LOG.error(_LE('Missing context in request, please check.')) return flask.Response(status=exception.error_code, headers=headers, response=json.dumps(response))
def test_parse_rrset_object_preserves_changes_multiple_rrs(self): old_ips = ['1.1.1.1', '2.2.2.2'] new_ips = ['2.2.2.2', '8.8.8.8'] original_records = objects.RecordList( objects=[ objects.Record(data=ip) for ip in old_ips ] ) rs = objects.RecordSet( name='www.example.org.', type='A', records=original_records ) body = { 'records': new_ips } rs = DesignateAdapter.parse('API_v2', body, rs) self.assertIn('records', rs.obj_what_changed()) def get_data(record_list): return set([r.data for r in record_list]) self.assertEqual(set(old_ips), get_data(rs.obj_get_original_value('records'))) self.assertEqual(set(new_ips), get_data(rs.obj_get_changes()['records']))
def post_all(self): """Create Zone Import""" request = pecan.request response = pecan.response context = request.environ['context'] if six.PY2: body = request.body else: body = request.body.decode('utf-8') if request.content_type != 'text/dns': raise exceptions.UnsupportedContentType( 'Content-type must be text/dns') # Create the zone_import zone_import = self.central_api.create_zone_import( context, body) response.status_int = 202 LOG.info(_LI("Created %(zone_import)s"), {'zone_import': zone_import}) zone_import = DesignateAdapter.render( 'API_v2', zone_import, request=request) response.headers['Location'] = zone_import['links']['self'] # Prepare and return the response body return zone_import
def get_all(self, zone_id, **params): """List RecordSets""" request = pecan.request context = request.environ['context'] # NOTE: We need to ensure the zone actually exists, otherwise we may # return deleted recordsets instead of a zone not found self.central_api.get_zone(context, zone_id) # Extract the pagination params marker, limit, sort_key, sort_dir = utils.get_paging_params( params, self.SORT_KEYS) # Extract any filter params. accepted_filters = ( 'name', 'type', 'ttl', 'data', 'status', 'description', ) criterion = self._apply_filter_params( params, accepted_filters, {}) criterion['zone_id'] = zone_id recordsets = self.central_api.find_recordsets( context, criterion, marker, limit, sort_key, sort_dir) LOG.info(_LI("Retrieved %(recordsets)s"), {'recordsets': recordsets}) return DesignateAdapter.render('API_v2', recordsets, request=request)
def get_all(self, zone_id, **params): """List RecordSets""" request = pecan.request context = request.environ['context'] recordsets = common.retrieve_matched_rrsets(context, self, zone_id, **params) return DesignateAdapter.render('API_v2', recordsets, request=request)
def get_one(self, tenant_id): context = pecan.request.environ['context'] quotas = self.central_api.get_quotas(context, tenant_id) quotas = QuotaList.from_dict(quotas) return DesignateAdapter.render('API_v2', quotas)
def post_all(self): """Create Zone""" request = pecan.request response = pecan.response context = request.environ['context'] zone = request.body_dict # We need to check the zone type before validating the schema since if # it's the type is SECONDARY we need to set the email to the mgmt email if isinstance(zone, dict): if 'type' not in zone: zone['type'] = 'PRIMARY' if zone['type'] == 'SECONDARY': mgmt_email = CONF['service:central'].managed_resource_email zone['email'] = mgmt_email zone = DesignateAdapter.parse('API_v2', zone, objects.Domain()) zone.validate() # # TODO(ekarlso): Fix this once setter or so works. # masters = values.pop('masters', []) # zone = objects.Domain.from_dict(values) # zone.set_masters(masters) # Create the zone zone = self.central_api.create_domain(context, zone) # Prepare the response headers # If the zone has been created asynchronously if zone['status'] == 'PENDING': response.status_int = 202 else: response.status_int = 201 # Prepare and return the response body zone = DesignateAdapter.render('API_v2', zone, request=request) response.headers['Location'] = zone['links']['self'] return zone
def get_all(self, **params): """List Floating IP PTRs for a Tenant""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.list_floatingips(context), request=request)
def get_one(self, pool_id): """Get the specific Pool""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_pool(context, pool_id), request=request)
def put_one(self, zone_id, recordset_id): """Update RecordSet""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response # Fetch the existing recordset recordset = self.central_api.get_recordset(context, zone_id, recordset_id) # TODO(graham): Move this further down the stack if recordset.managed and not context.edit_managed_records: raise exceptions.BadRequest('Managed records may not be updated') # SOA recordsets cannot be updated manually if recordset['type'] == 'SOA': raise exceptions.BadRequest( 'Updating SOA recordsets is not allowed') # NS recordsets at the zone root cannot be manually updated if recordset['type'] == 'NS': zone = self.central_api.get_zone(context, zone_id) if recordset['name'] == zone['name']: raise exceptions.BadRequest( 'Updating a root zone NS record is not allowed') # Convert to APIv2 Format recordset = DesignateAdapter.parse('API_v2', body, recordset) recordset.validate() # Persist the resource recordset = self.central_api.update_recordset(context, recordset) LOG.info(_LI("Updated %(recordset)s"), {'recordset': recordset}) if recordset['status'] == 'PENDING': response.status_int = 202 else: response.status_int = 200 return DesignateAdapter.render('API_v2', recordset, request=request)
def get_all(self, zone_id, **params): """List RecordSets""" request = pecan.request context = request.environ['context'] # NOTE: We need to ensure the domain actually exists, otherwise we may # return deleted recordsets instead of a domain not found self.central_api.get_domain(context, zone_id) # Extract the pagination params marker, limit, sort_key, sort_dir = utils.get_paging_params( params, self.SORT_KEYS) # Extract any filter params. accepted_filters = ( 'name', 'type', 'ttl', 'data', 'status', 'description', ) criterion = self._apply_filter_params( params, accepted_filters, {}) criterion['domain_id'] = zone_id # Data must be filtered separately, through the Records table data = criterion.pop('data', None) status = criterion.pop('status', None) # Retrieve recordsets recordsets = self.central_api.find_recordsets( context, criterion, marker, limit, sort_key, sort_dir) # 'data' filter param: only return recordsets with matching data if data: records = self.central_api.find_records( context, criterion={'data': data, 'domain_id': zone_id}) recordset_with_data_ids = set(record.recordset_id for record in records) new_rsets = RecordSetList() for recordset in recordsets: if recordset.id in recordset_with_data_ids: new_rsets.append(recordset) recordsets = new_rsets recordsets.total_count = len(recordset_with_data_ids) # 'status' filter param: only return recordsets with matching status if status: new_rsets = RecordSetList() for recordset in recordsets: if recordset.status == status: new_rsets.append(recordset) recordsets = new_rsets return DesignateAdapter.render('API_v2', recordsets, request=request)
def get_one(self, pool_id): """Get the specific Pool""" request = pecan.request context = request.environ['context'] pool = self.central_api.get_pool(context, pool_id) LOG.info(_LI("Retrieved %(pool)s"), {'pool': pool}) return DesignateAdapter.render('API_v2', pool, request=request)
def get_all(self, **params): """List Floating IP PTRs for a Tenant""" request = pecan.request context = request.environ['context'] fips = self.central_api.list_floatingips(context) LOG.info("Retrieved %(fips)s", {'fips': fips}) return DesignateAdapter.render('API_v2', fips, request=request)
def get_all(self, **params): """List RecordSets""" request = pecan.request context = request.environ['context'] recordsets = common.retrieve_matched_rrsets(context, self, None, **params) LOG.info("Retrieved %(recordsets)s", {'recordsets': recordsets}) return DesignateAdapter.render('API_v2', recordsets, request=request)
def get_one(self, zone_id, recordset_id): """Get RecordSet""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_recordset( context, zone_id, recordset_id), request=request)
def get_one(self, blacklist_id): """Get Blacklist""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_blacklist(context, blacklist_id), request=request)
def delete_one(self, zone_id): """Delete Zone""" request = pecan.request response = pecan.response context = request.environ['context'] zone = self.central_api.delete_zone(context, zone_id) response.status_int = 202 return DesignateAdapter.render('API_v2', zone, request=request)
def post_all(self): """Create a Pool""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict pool = DesignateAdapter.parse('API_v2', body, Pool()) pool.validate() # Create the pool pool = self.central_api.create_pool(context, pool) pool = DesignateAdapter.render('API_v2', pool, request=request) response.status_int = 201 response.headers['Location'] = pool['links']['self'] # Prepare and return the response body return pool
def get_one(self, tld_id): """Get Tld""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_tld(context, tld_id), request=request)
def get_one(self, zone_id): """Get Zone""" # TODO(kiall): Validate we have a sane UUID for zone_id request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_zone(context, zone_id), request=request)
def get_one(self, tld_id): """Get Tld""" request = pecan.request context = request.environ['context'] tld = self.central_api.get_tld(context, tld_id) LOG.info(_LI("Retrieved %(tld)s"), {'tld': tld}) return DesignateAdapter.render('API_v2', tld, request=request)
def post_all(self): """Create TsigKey""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict tsigkey = DesignateAdapter.parse('API_v2', body, TsigKey()) tsigkey.validate() # Create the tsigkey tsigkey = self.central_api.create_tsigkey(context, tsigkey) tsigkey = DesignateAdapter.render('API_v2', tsigkey, request=request) response.headers['Location'] = tsigkey['links']['self'] response.status_int = 201 # Prepare and return the response body return tsigkey
def get_one(self, tsigkey_id): """Get TsigKey""" request = pecan.request context = request.environ['context'] tsigkey = self.central_api.get_tsigkey(context, tsigkey_id) LOG.info("Retrieved %(tsigkey)s", {'tsigkey': tsigkey}) return DesignateAdapter.render('API_v2', tsigkey, request=request)
def get_one(self, export_id): """Get Zone Exports""" request = pecan.request context = request.environ['context'] zone_export = self.central_api.get_zone_export(context, export_id) LOG.info("Retrieved %(export)s", {'export': zone_export}) return DesignateAdapter.render('API_v2', zone_export, request=request)
def get_one(self, rbac_id): """Get RBAC parameter""" request = pecan.request context = request.environ['context'] rbacrule = self.central_api.get_rbacrule(context, rbac_id) LOG.info("Retrieved %(rbacrule)s", {'rbacrule': rbacrule}) return DesignateAdapter.render('API_v2', rbacrule, request=request)
def get_one(self, transfer_accept_id): """Get transfer_accepts""" request = pecan.request context = request.environ['context'] return DesignateAdapter.render( 'API_v2', self.central_api.get_zone_transfer_accept(context, transfer_accept_id), request=request)
def post_all(self): """Create Tld""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict tld = DesignateAdapter.parse('API_v2', body, Tld()) tld.validate() # Create the tld tld = self.central_api.create_tld(context, tld) response.status_int = 201 tld = DesignateAdapter.render('API_v2', tld, request=request) response.headers['Location'] = tld['links']['self'] # Prepare and return the response body return tld
def get_one(self, blacklist_id): """Get Blacklist""" request = pecan.request context = request.environ['context'] blacklist = self.central_api.get_blacklist(context, blacklist_id) LOG.info("Retrieved %(blacklist)s", {'blacklist': blacklist}) return DesignateAdapter.render('API_v2', blacklist, request=request)
def get_one(self, service_id): """Get Service Status""" request = pecan.request context = request.environ['context'] criterion = {"id": service_id} service_status = self.central_api.find_service_status( context, criterion) return DesignateAdapter.render( 'API_v2', service_status, request=request)
def get_one(self, import_id): """Get Zone Imports""" request = pecan.request context = request.environ['context'] zone_import = self.central_api.get_zone_import(context, import_id) LOG.info(_LI("Retrived %(zone_import)s"), {'zone_import': zone_import}) return DesignateAdapter.render('API_v2', zone_import, request=request)
def generate_file(self, file): self._startup() try: pools = self.central_api.find_pools(self.context) except messaging.exceptions.MessagingTimeout: LOG.critical("No response received from designate-central. " "Check it is running, and retry") sys.exit(1) with open(file, 'w') as stream: yaml.dump(DesignateAdapter.render('YAML', pools), stream, default_flow_style=False)
def patch_one(self, tld_id): """Update Tld""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing tld tld = self.central_api.get_tld(context, tld_id) tld = DesignateAdapter.parse('API_v2', body, tld) tld.validate() tld = self.central_api.update_tld(context, tld) response.status_int = 200 return DesignateAdapter.render('API_v2', tld, request=request)
def delete_one(self, zone_id): """Delete Zone""" request = pecan.request response = pecan.response context = request.environ['context'] zone = self.central_api.delete_zone(context, zone_id) response.status_int = 202 LOG.info(_LI("Deleted %(zone)s"), {'zone': zone}) return DesignateAdapter.render('API_v2', zone, request=request)
def get_one(self, zone_id): """Get Zone""" # TODO(kiall): Validate we have a sane UUID for zone_id request = pecan.request context = request.environ['context'] zone = self.central_api.get_zone(context, zone_id) LOG.info("Retrieved %(zone)s", {'zone': zone}) return DesignateAdapter.render('API_v2', zone, request=request)
def get_one(self, fip_key): """ Get PTR """ request = pecan.request context = request.environ['context'] region, id_ = fip_key_to_data(fip_key) return DesignateAdapter.render('API_v2', self.central_api.get_floatingip( context, region, id_), request=request)
def patch_one(self, blacklist_id): """Update Blacklisted Zone""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing blacklist entry blacklist = self.central_api.get_blacklist(context, blacklist_id) blacklist = DesignateAdapter.parse('API_v2', body, blacklist) blacklist.validate() blacklist = self.central_api.update_blacklist(context, blacklist) response.status_int = 200 return DesignateAdapter.render('API_v2', blacklist, request=request)
def post_all(self): """Create Zone""" request = pecan.request response = pecan.response context = request.environ['context'] zone = request.body_dict # We need to check the zone type before validating the schema since if # it's the type is SECONDARY we need to set the email to the mgmt email if isinstance(zone, dict): if 'type' not in zone: zone['type'] = 'PRIMARY' zone = DesignateAdapter.parse('API_v2', zone, objects.Zone()) zone.validate() if zone.type == 'SECONDARY': mgmt_email = CONF['service:central'].managed_resource_email zone['email'] = mgmt_email # Create the zone zone = self.central_api.create_zone(context, zone) # Prepare the response headers # If the zone has been created asynchronously if zone['status'] == 'PENDING': response.status_int = 202 else: response.status_int = 201 # Prepare and return the response body zone = DesignateAdapter.render('API_v2', zone, request=request) response.headers['Location'] = zone['links']['self'] return zone
def patch_one(self, pool_id): """Update the specific pool""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing pool pool = self.central_api.get_pool(context, pool_id) pool = DesignateAdapter.parse('API_v2', body, pool) pool.validate() pool = self.central_api.update_pool(context, pool) response.status_int = 200 return DesignateAdapter.render('API_v2', pool, request=request)
def show_config(self, pool_id): try: pool = self.central_api.find_pool(self.context, {"id": pool_id}) print('Pool Configuration:') print('-------------------') print(yaml.dump(DesignateAdapter.render('YAML', pool), default_flow_style=False)) except messaging.exceptions.MessagingTimeout: LOG.critical(_LC("No response received from designate-central. " "Check it is running, and retry"))
def get_one(self, transfer_accept_id): """Get transfer_accepts""" request = pecan.request context = request.environ['context'] transfer_accepts = self.central_api.get_zone_transfer_accept( context, transfer_accept_id) LOG.info(_LI("Retrieved %(transfer_accepts)s"), {'transfer_accepts': transfer_accepts}) return DesignateAdapter.render( 'API_v2', transfer_accepts, request=request)
def get_one(self, fip_key): """ Get PTR """ request = pecan.request context = request.environ['context'] region, id_ = fip_key_to_data(fip_key) fip = self.central_api.get_floatingip(context, region, id_) LOG.info(_LI("Retrieved %(fip)s"), {'fip': fip}) return DesignateAdapter.render('API_v2', fip, request=request)
def post_all(self): request = pecan.request response = pecan.response context = pecan.request.environ['context'] policy.check('zone_import', context) if request.content_type != 'text/dns': raise exceptions.UnsupportedContentType( 'Content-type must be text/dns') try: dnspython_zone = dnszone.from_text( request.body, # Don't relativize, otherwise we end up with '@' record names. relativize=False, # Dont check origin, we allow missing NS records (missing SOA # records are taken care of in _create_zone). check_origin=False) domain = dnsutils.from_dnspython_zone(dnspython_zone) domain.type = 'PRIMARY' for rrset in list(domain.recordsets): if rrset.type in ('NS', 'SOA'): domain.recordsets.remove(rrset) except dnszone.UnknownOrigin: raise exceptions.BadRequest('The $ORIGIN statement is required and' ' must be the first statement in the' ' zonefile.') except dnsexception.SyntaxError: raise exceptions.BadRequest('Malformed zonefile.') zone = self.central_api.create_domain(context, domain) if zone['status'] == 'PENDING': response.status_int = 202 else: response.status_int = 201 zone = DesignateAdapter.render('API_v2', zone, request=request) zone['links']['self'] = '%s/%s/%s' % (self.BASE_URI, 'v2/zones', zone['id']) response.headers['Location'] = zone['links']['self'] return zone
def patch_one(self, tenant_id): """Modify a Quota""" request = pecan.request context = request.environ['context'] body = request.body_dict # NOTE(pas-ha) attempting to verify the validity of the project-id # on a best effort basis # this will raise only if KeystoneV3 endpoint is not found at all, # or the creds are passing but the project is not found if cfg.CONF['service:api'].quotas_verify_project_id: keystone.verify_project_id(context, tenant_id) quotas = DesignateAdapter.parse('API_v2', body, QuotaList()) for quota in quotas: self.central_api.set_quota(context, tenant_id, quota.resource, quota.hard_limit) quotas = self.central_api.get_quotas(context, tenant_id) quotas = QuotaList.from_dict(quotas) return DesignateAdapter.render('API_v2', quotas)
def post_all(self): """Create a Pool""" LOG.warning(_LW("Use of this API Method is DEPRICATED. This will have " "unforseen side affects when used with the " "designate-manage pool commands")) request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict pool = DesignateAdapter.parse('API_v2', body, Pool()) pool.validate() # Create the pool pool = self.central_api.create_pool(context, pool) pool = DesignateAdapter.render('API_v2', pool, request=request) response.status_int = 201 response.headers['Location'] = pool['links']['self'] # Prepare and return the response body return pool
def patch_one(self, rbac_id): """Update RBAC rule""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing rbac entry rbac = self.central_api.get_rbacrule(context, rbac_id) rbac = DesignateAdapter.parse('API_v2', body, rbac) rbac.validate() rbac = self.central_api.update_rbacrule(context, rbac) LOG.info("Updated %(rbac)s", {'rbac': rbac}) response.status_int = 200 return DesignateAdapter.render('API_v2', rbac, request=request)
def patch_one(self, tsigkey_id): """Update TsigKey""" request = pecan.request context = request.environ['context'] body = request.body_dict response = pecan.response if request.content_type == 'application/json-patch+json': raise NotImplemented('json-patch not implemented') # Fetch the existing tsigkey entry tsigkey = self.central_api.get_tsigkey(context, tsigkey_id) tsigkey = DesignateAdapter.parse('API_v2', body, tsigkey) # Validate the new set of data tsigkey.validate() # Update and persist the resource tsigkey = self.central_api.update_tsigkey(context, tsigkey) response.status_int = 200 return DesignateAdapter.render('API_v2', tsigkey, request=request)
def post_all(self): """Create Blacklisted Zone""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict blacklist = DesignateAdapter.parse('API_v2', body, Blacklist()) blacklist.validate() # Create the blacklist blacklist = self.central_api.create_blacklist(context, blacklist) response.status_int = 201 blacklist = DesignateAdapter.render('API_v2', blacklist, request=request) response.headers['Location'] = blacklist['links']['self'] # Prepare and return the response body return blacklist
def post_all(self): """Create ZoneTransferAccept""" request = pecan.request response = pecan.response context = request.environ['context'] body = request.body_dict zone_transfer_accept = DesignateAdapter.parse('API_v2', body, ZoneTransferAccept()) zone_transfer_accept.validate() # Create the zone_transfer_request zone_transfer_accept = self.central_api.create_zone_transfer_accept( context, zone_transfer_accept) response.status_int = 201 zone_transfer_accept = DesignateAdapter.render('API_v2', zone_transfer_accept, request=request) response.headers['Location'] = zone_transfer_accept['links']['self'] # Prepare and return the response body return zone_transfer_accept
def get_all(self, zone_id): """List NameServers for Zone""" request = pecan.request context = request.environ['context'] # This is a work around to overcome the fact that pool ns_records list # object have 2 different representations in the v2 API return { "nameservers": DesignateAdapter.render('API_v2', self.central_api.get_zone_ns_records( context, zone_id), request=request) }