openstack
/
python-designateclient
Code Issues Proposed changes

Merge "Removing unused code"

This commit is contained in:
Zuul 2019-09-28 04:55:06 +00:00 committed by Gerrit Code Review
parent b230eca4d6 11e7e4bbc1
commit eb3c72cd89
2 changed files with 0 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
designateclient/utils.py
View File

@ -16,11 +16,7 @@
import uuid import uuid
from debtcollector import removals
from keystoneauth1 import adapter from keystoneauth1 import adapter
from keystoneauth1.identity import generic
from keystoneauth1 import session as ks_session
from keystoneauth1 import token_endpoint
import six import six
from designateclient import exceptions from designateclient import exceptions
@ -73,61 +69,6 @@ def get_columns(data):
return list(columns) return list(columns)
@removals.removed_kwarg('all_tenants', removal_version='1.3.0')
@removals.removed_kwarg('edit_managed', removal_version='1.3.0')
def get_session(auth_url, endpoint, domain_id, domain_name, project_id,
project_name, project_domain_name, project_domain_id, username,
user_id, password, user_domain_id, user_domain_name, token,
insecure, cacert, all_tenants=False, edit_managed=False):
# NOTE: all_tenants and edit_managed are here for backwards compat
# reasons, do not add additional modifiers here.
session = ks_session.Session()
# Build + Attach Authentication Plugin
auth_args = {
'auth_url': auth_url,
'domain_id': domain_id,
'domain_name': domain_name,
'project_id': project_id,
'project_name': project_name,
'project_domain_name': project_domain_name,
'project_domain_id': project_domain_id,
}
if token and endpoint:
session.auth = token_endpoint.Token(endpoint, token)
elif token:
auth_args.update({
'token': token
})
session.auth = generic.Token(**auth_args)
else:
auth_args.update({
'username': username,
'user_id': user_id,
'password': password,
'user_domain_id': user_domain_id,
'user_domain_name': user_domain_name,
})
session.auth = generic.Password(**auth_args)
# SSL/TLS Server Cert Verification
if insecure is True:
session.verify = False
else:
session.verify = cacert
# NOTE: all_tenants and edit_managed are here for backwards compat
# reasons, do not add additional modifiers here.
session.all_tenants = all_tenants
session.edit_managed = edit_managed
return session
def find_resourceid_by_name_or_id(resource_client, name_or_id): def find_resourceid_by_name_or_id(resource_client, name_or_id):
"""Find resource id from its id or name.""" """Find resource id from its id or name."""
try: try:

135
designateclient/warlock.py
View File

@ -1,135 +0,0 @@
# Copyright 2012 Brian Waldon
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
# Code copied from Warlock, as warlock depends on jsonschema==0.2
# Hopefully we can upstream the changes ASAP.
#
import copy
import logging
import jsonschema
import six
LOG = logging.getLogger(__name__)
class InvalidOperation(RuntimeError):
pass
class ValidationError(ValueError):
pass
def model_factory(schema):
"""Generate a model class based on the provided JSON Schema
:param schema: dict representing valid JSON schema
"""
schema = copy.deepcopy(schema)
def validator(obj):
"""Apply a JSON schema to an object"""
try:
jsonschema.validate(obj, schema, cls=jsonschema.Draft3Validator)
except jsonschema.ValidationError as e:
raise ValidationError(str(e))
class Model(dict):
"""Self-validating model for arbitrary objects"""
def __init__(self, *args, **kwargs):
d = dict(*args, **kwargs)
# we overload setattr so set this manually
self.__dict__['validator'] = validator
try:
self.validator(d)
except ValidationError as e:
raise ValueError('Validation Error: %s' % str(e))
else:
dict.__init__(self, d)
self.__dict__['changes'] = {}
def __getattr__(self, key):
try:
return self.__getitem__(key)
except KeyError:
raise AttributeError(key)
def __setitem__(self, key, value):
mutation = dict(self.items())
mutation[key] = value
try:
self.validator(mutation)
except ValidationError as e:
raise InvalidOperation(str(e))
dict.__setitem__(self, key, value)
self.__dict__['changes'][key] = value
def __setattr__(self, key, value):
self.__setitem__(key, value)
def clear(self):
raise InvalidOperation()
def pop(self, key, default=None):
raise InvalidOperation()
def popitem(self):
raise InvalidOperation()
def __delitem__(self, key):
raise InvalidOperation()
# NOTE(termie): This is kind of the opposite of what copy usually does
def copy(self):
return copy.deepcopy(dict(self))
def update(self, other):
# NOTE(kiall): It seems update() doesn't update the
# self.__dict__['changes'] dict correctly.
mutation = dict(self.items())
mutation.update(other)
try:
self.validator(mutation)
except ValidationError as e:
raise InvalidOperation(str(e))
dict.update(self, other)
def iteritems(self):
return six.iteritems(copy.deepcopy(dict(self)))
def items(self):
return list(six.iteritems(copy.deepcopy(dict(self))))
def itervalues(self):
return six.itervalues(copy.deepcopy(dict(self)))
def keys(self):
return list(six.iterkeys(copy.deepcopy(dict(self))))
def values(self):
return list(six.itervalues(copy.deepcopy(dict(self))))
@property
def changes(self):
return copy.deepcopy(self.__dict__['changes'])
Model.__name__ = str(schema['title'])
return Model