Browse Source

Merge "Removing unused code"

tags/3.1.0^0
Zuul 9 months ago
committed by Gerrit Code Review
parent
commit
eb3c72cd89
2 changed files with 0 additions and 194 deletions
  1. +0
    -59
      designateclient/utils.py
  2. +0
    -135
      designateclient/warlock.py

+ 0
- 59
designateclient/utils.py View File

@@ -16,11 +16,7 @@

import uuid

from debtcollector import removals
from keystoneauth1 import adapter
from keystoneauth1.identity import generic
from keystoneauth1 import session as ks_session
from keystoneauth1 import token_endpoint
import six

from designateclient import exceptions
@@ -73,61 +69,6 @@ def get_columns(data):
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):
"""Find resource id from its id or name."""
try:


+ 0
- 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

Loading…
Cancel
Save