Example #1
0
    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
Example #3
0
    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
Example #5
0
    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)
Example #6
0
    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)
Example #7
0
    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
Example #8
0
    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
Example #9
0
    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)
Example #10
0
    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
Example #11
0
    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)
Example #12
0
    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))
Example #13
0
    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']))
Example #14
0
    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
Example #15
0
    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)
Example #16
0
    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)
Example #17
0
    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)
Example #18
0
    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
Example #19
0
    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)
Example #20
0
    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)
Example #21
0
    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)
Example #22
0
    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)
Example #23
0
    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)
Example #24
0
    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)
Example #25
0
    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)
Example #26
0
    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)
Example #27
0
    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)
Example #28
0
    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)
Example #29
0
    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
Example #30
0
    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)
Example #31
0
    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)
Example #32
0
    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)
Example #33
0
    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
Example #34
0
    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)
Example #35
0
    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)
Example #36
0
    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)
Example #37
0
    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)
Example #38
0
    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
Example #39
0
    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)
Example #40
0
    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)
Example #41
0
    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)
Example #42
0
 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)
Example #43
0
    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)
Example #44
0
    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)
Example #45
0
    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)
Example #46
0
    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)
Example #47
0
    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)
Example #48
0
    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
Example #49
0
    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)
Example #50
0
    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)
Example #52
0
    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)
Example #53
0
    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
Example #54
0
    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)
Example #55
0
    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
Example #56
0
    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)
Example #57
0
    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)
Example #58
0
    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
Example #59
0
    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
Example #60
0
    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)
        }