598 lines
20 KiB
Python
598 lines
20 KiB
Python
# Copyright 2013 OpenStack Foundation
|
|
# Copyright 2013 IBM Corp.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
|
|
def _proxy(target, attr):
|
|
def get_attr(self):
|
|
return getattr(getattr(self, target), attr)
|
|
|
|
def set_attr(self, value):
|
|
return setattr(getattr(self, target), attr, value)
|
|
|
|
def del_attr(self):
|
|
return delattr(getattr(self, target), attr)
|
|
|
|
return property(get_attr, set_attr, del_attr)
|
|
|
|
|
|
class Helper(object):
|
|
def __init__(self, proxy_class=None, proxy_kwargs=None):
|
|
self.proxy_class = proxy_class
|
|
self.proxy_kwargs = proxy_kwargs or {}
|
|
|
|
def proxy(self, obj):
|
|
if obj is None or self.proxy_class is None:
|
|
return obj
|
|
return self.proxy_class(obj, **self.proxy_kwargs)
|
|
|
|
def unproxy(self, obj):
|
|
if obj is None or self.proxy_class is None:
|
|
return obj
|
|
return obj.base
|
|
|
|
|
|
class TaskRepo(object):
|
|
def __init__(self, base,
|
|
task_proxy_class=None, task_proxy_kwargs=None):
|
|
self.base = base
|
|
self.task_proxy_helper = Helper(task_proxy_class, task_proxy_kwargs)
|
|
|
|
def get(self, task_id):
|
|
task = self.base.get(task_id)
|
|
return self.task_proxy_helper.proxy(task)
|
|
|
|
def add(self, task):
|
|
self.base.add(self.task_proxy_helper.unproxy(task))
|
|
|
|
def save(self, task):
|
|
self.base.save(self.task_proxy_helper.unproxy(task))
|
|
|
|
def remove(self, task):
|
|
base_task = self.task_proxy_helper.unproxy(task)
|
|
self.base.remove(base_task)
|
|
|
|
|
|
class TaskStubRepo(object):
|
|
def __init__(self, base, task_stub_proxy_class=None,
|
|
task_stub_proxy_kwargs=None):
|
|
self.base = base
|
|
self.task_stub_proxy_helper = Helper(task_stub_proxy_class,
|
|
task_stub_proxy_kwargs)
|
|
|
|
def list(self, *args, **kwargs):
|
|
tasks = self.base.list(*args, **kwargs)
|
|
return [self.task_stub_proxy_helper.proxy(task) for task in tasks]
|
|
|
|
|
|
class Repo(object):
|
|
def __init__(self, base, item_proxy_class=None, item_proxy_kwargs=None):
|
|
self.base = base
|
|
self.helper = Helper(item_proxy_class, item_proxy_kwargs)
|
|
|
|
def get(self, item_id):
|
|
return self.helper.proxy(self.base.get(item_id))
|
|
|
|
def list(self, *args, **kwargs):
|
|
items = self.base.list(*args, **kwargs)
|
|
return [self.helper.proxy(item) for item in items]
|
|
|
|
def add(self, item):
|
|
base_item = self.helper.unproxy(item)
|
|
result = self.base.add(base_item)
|
|
return self.helper.proxy(result)
|
|
|
|
def save(self, item, from_state=None):
|
|
base_item = self.helper.unproxy(item)
|
|
result = self.base.save(base_item, from_state=from_state)
|
|
return self.helper.proxy(result)
|
|
|
|
def remove(self, item):
|
|
base_item = self.helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.helper.proxy(result)
|
|
|
|
def set_property_atomic(self, item, name, value):
|
|
msg = '%s is only valid for images' % __name__
|
|
assert hasattr(item, 'image_id'), msg
|
|
self.base.set_property_atomic(item, name, value)
|
|
|
|
def delete_property_atomic(self, item, name, value):
|
|
msg = '%s is only valid for images' % __name__
|
|
assert hasattr(item, 'image_id'), msg
|
|
self.base.delete_property_atomic(item, name, value)
|
|
|
|
|
|
class MemberRepo(object):
|
|
def __init__(self, image, base,
|
|
member_proxy_class=None, member_proxy_kwargs=None):
|
|
self.image = image
|
|
self.base = base
|
|
self.member_proxy_helper = Helper(member_proxy_class,
|
|
member_proxy_kwargs)
|
|
|
|
def get(self, member_id):
|
|
member = self.base.get(member_id)
|
|
return self.member_proxy_helper.proxy(member)
|
|
|
|
def add(self, member):
|
|
self.base.add(self.member_proxy_helper.unproxy(member))
|
|
|
|
def list(self, *args, **kwargs):
|
|
members = self.base.list(*args, **kwargs)
|
|
return [self.member_proxy_helper.proxy(member) for member
|
|
in members]
|
|
|
|
def remove(self, member):
|
|
base_item = self.member_proxy_helper.unproxy(member)
|
|
result = self.base.remove(base_item)
|
|
return self.member_proxy_helper.proxy(result)
|
|
|
|
def save(self, member, from_state=None):
|
|
base_item = self.member_proxy_helper.unproxy(member)
|
|
result = self.base.save(base_item, from_state=from_state)
|
|
return self.member_proxy_helper.proxy(result)
|
|
|
|
|
|
class ImageFactory(object):
|
|
def __init__(self, base, proxy_class=None, proxy_kwargs=None):
|
|
self.helper = Helper(proxy_class, proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_image(self, **kwargs):
|
|
return self.helper.proxy(self.base.new_image(**kwargs))
|
|
|
|
|
|
class ImageMembershipFactory(object):
|
|
def __init__(self, base, proxy_class=None, proxy_kwargs=None):
|
|
self.helper = Helper(proxy_class, proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_image_member(self, image, member, **kwargs):
|
|
return self.helper.proxy(self.base.new_image_member(image,
|
|
member,
|
|
**kwargs))
|
|
|
|
|
|
class Image(object):
|
|
def __init__(self, base, member_repo_proxy_class=None,
|
|
member_repo_proxy_kwargs=None):
|
|
self.base = base
|
|
self.helper = Helper(member_repo_proxy_class,
|
|
member_repo_proxy_kwargs)
|
|
|
|
name = _proxy('base', 'name')
|
|
image_id = _proxy('base', 'image_id')
|
|
status = _proxy('base', 'status')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
visibility = _proxy('base', 'visibility')
|
|
min_disk = _proxy('base', 'min_disk')
|
|
min_ram = _proxy('base', 'min_ram')
|
|
protected = _proxy('base', 'protected')
|
|
os_hidden = _proxy('base', 'os_hidden')
|
|
locations = _proxy('base', 'locations')
|
|
checksum = _proxy('base', 'checksum')
|
|
os_hash_algo = _proxy('base', 'os_hash_algo')
|
|
os_hash_value = _proxy('base', 'os_hash_value')
|
|
owner = _proxy('base', 'owner')
|
|
disk_format = _proxy('base', 'disk_format')
|
|
container_format = _proxy('base', 'container_format')
|
|
size = _proxy('base', 'size')
|
|
virtual_size = _proxy('base', 'virtual_size')
|
|
extra_properties = _proxy('base', 'extra_properties')
|
|
tags = _proxy('base', 'tags')
|
|
member = _proxy('base', 'member')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
def deactivate(self):
|
|
self.base.deactivate()
|
|
|
|
def reactivate(self):
|
|
self.base.reactivate()
|
|
|
|
def set_data(self, data, size=None, backend=None, set_active=True):
|
|
self.base.set_data(data, size, backend=backend, set_active=set_active)
|
|
|
|
def get_data(self, *args, **kwargs):
|
|
return self.base.get_data(*args, **kwargs)
|
|
|
|
|
|
class ImageMember(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
|
|
id = _proxy('base', 'id')
|
|
image_id = _proxy('base', 'image_id')
|
|
member_id = _proxy('base', 'member_id')
|
|
status = _proxy('base', 'status')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
|
|
class Task(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
|
|
task_id = _proxy('base', 'task_id')
|
|
type = _proxy('base', 'type')
|
|
status = _proxy('base', 'status')
|
|
owner = _proxy('base', 'owner')
|
|
expires_at = _proxy('base', 'expires_at')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
task_input = _proxy('base', 'task_input')
|
|
result = _proxy('base', 'result')
|
|
message = _proxy('base', 'message')
|
|
image_id = _proxy('base', 'image_id')
|
|
request_id = _proxy('base', 'request_id')
|
|
user_id = _proxy('base', 'user_id')
|
|
|
|
def begin_processing(self):
|
|
self.base.begin_processing()
|
|
|
|
def succeed(self, result):
|
|
self.base.succeed(result)
|
|
|
|
def fail(self, message):
|
|
self.base.fail(message)
|
|
|
|
def run(self, executor):
|
|
self.base.run(executor)
|
|
|
|
|
|
class TaskStub(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
|
|
task_id = _proxy('base', 'task_id')
|
|
type = _proxy('base', 'type')
|
|
status = _proxy('base', 'status')
|
|
owner = _proxy('base', 'owner')
|
|
expires_at = _proxy('base', 'expires_at')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
|
|
class TaskFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
task_proxy_class=None,
|
|
task_proxy_kwargs=None):
|
|
self.task_helper = Helper(task_proxy_class, task_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_task(self, **kwargs):
|
|
t = self.base.new_task(**kwargs)
|
|
return self.task_helper.proxy(t)
|
|
|
|
|
|
# Metadef Namespace classes
|
|
class MetadefNamespaceRepo(object):
|
|
def __init__(self, base,
|
|
namespace_proxy_class=None, namespace_proxy_kwargs=None):
|
|
self.base = base
|
|
self.namespace_proxy_helper = Helper(namespace_proxy_class,
|
|
namespace_proxy_kwargs)
|
|
|
|
def get(self, namespace):
|
|
namespace_obj = self.base.get(namespace)
|
|
return self.namespace_proxy_helper.proxy(namespace_obj)
|
|
|
|
def add(self, namespace):
|
|
self.base.add(self.namespace_proxy_helper.unproxy(namespace))
|
|
|
|
def list(self, *args, **kwargs):
|
|
namespaces = self.base.list(*args, **kwargs)
|
|
return [self.namespace_proxy_helper.proxy(namespace) for namespace
|
|
in namespaces]
|
|
|
|
def remove(self, item):
|
|
base_item = self.namespace_proxy_helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.namespace_proxy_helper.proxy(result)
|
|
|
|
def remove_objects(self, item):
|
|
base_item = self.namespace_proxy_helper.unproxy(item)
|
|
result = self.base.remove_objects(base_item)
|
|
return self.namespace_proxy_helper.proxy(result)
|
|
|
|
def remove_properties(self, item):
|
|
base_item = self.namespace_proxy_helper.unproxy(item)
|
|
result = self.base.remove_properties(base_item)
|
|
return self.namespace_proxy_helper.proxy(result)
|
|
|
|
def remove_tags(self, item):
|
|
base_item = self.namespace_proxy_helper.unproxy(item)
|
|
result = self.base.remove_tags(base_item)
|
|
return self.namespace_proxy_helper.proxy(result)
|
|
|
|
def save(self, item):
|
|
base_item = self.namespace_proxy_helper.unproxy(item)
|
|
result = self.base.save(base_item)
|
|
return self.namespace_proxy_helper.proxy(result)
|
|
|
|
|
|
class MetadefNamespace(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
|
|
namespace_id = _proxy('base', 'namespace_id')
|
|
namespace = _proxy('base', 'namespace')
|
|
display_name = _proxy('base', 'display_name')
|
|
description = _proxy('base', 'description')
|
|
owner = _proxy('base', 'owner')
|
|
visibility = _proxy('base', 'visibility')
|
|
protected = _proxy('base', 'protected')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
|
|
class MetadefNamespaceFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
meta_namespace_proxy_class=None,
|
|
meta_namespace_proxy_kwargs=None):
|
|
self.meta_namespace_helper = Helper(meta_namespace_proxy_class,
|
|
meta_namespace_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_namespace(self, **kwargs):
|
|
t = self.base.new_namespace(**kwargs)
|
|
return self.meta_namespace_helper.proxy(t)
|
|
|
|
|
|
# Metadef object classes
|
|
class MetadefObjectRepo(object):
|
|
def __init__(self, base,
|
|
object_proxy_class=None, object_proxy_kwargs=None):
|
|
self.base = base
|
|
self.object_proxy_helper = Helper(object_proxy_class,
|
|
object_proxy_kwargs)
|
|
|
|
def get(self, namespace, object_name):
|
|
meta_object = self.base.get(namespace, object_name)
|
|
return self.object_proxy_helper.proxy(meta_object)
|
|
|
|
def add(self, meta_object):
|
|
self.base.add(self.object_proxy_helper.unproxy(meta_object))
|
|
|
|
def list(self, *args, **kwargs):
|
|
objects = self.base.list(*args, **kwargs)
|
|
return [self.object_proxy_helper.proxy(meta_object) for meta_object
|
|
in objects]
|
|
|
|
def remove(self, item):
|
|
base_item = self.object_proxy_helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.object_proxy_helper.proxy(result)
|
|
|
|
def save(self, item):
|
|
base_item = self.object_proxy_helper.unproxy(item)
|
|
result = self.base.save(base_item)
|
|
return self.object_proxy_helper.proxy(result)
|
|
|
|
|
|
class MetadefObject(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
namespace = _proxy('base', 'namespace')
|
|
object_id = _proxy('base', 'object_id')
|
|
name = _proxy('base', 'name')
|
|
required = _proxy('base', 'required')
|
|
description = _proxy('base', 'description')
|
|
properties = _proxy('base', 'properties')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
|
|
class MetadefObjectFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
meta_object_proxy_class=None,
|
|
meta_object_proxy_kwargs=None):
|
|
self.meta_object_helper = Helper(meta_object_proxy_class,
|
|
meta_object_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_object(self, **kwargs):
|
|
t = self.base.new_object(**kwargs)
|
|
return self.meta_object_helper.proxy(t)
|
|
|
|
|
|
# Metadef ResourceType classes
|
|
class MetadefResourceTypeRepo(object):
|
|
def __init__(self, base, resource_type_proxy_class=None,
|
|
resource_type_proxy_kwargs=None):
|
|
self.base = base
|
|
self.resource_type_proxy_helper = Helper(resource_type_proxy_class,
|
|
resource_type_proxy_kwargs)
|
|
|
|
def add(self, meta_resource_type):
|
|
self.base.add(self.resource_type_proxy_helper.unproxy(
|
|
meta_resource_type))
|
|
|
|
def get(self, *args, **kwargs):
|
|
resource_type = self.base.get(*args, **kwargs)
|
|
return self.resource_type_proxy_helper.proxy(resource_type)
|
|
|
|
def list(self, *args, **kwargs):
|
|
resource_types = self.base.list(*args, **kwargs)
|
|
return [self.resource_type_proxy_helper.proxy(resource_type)
|
|
for resource_type in resource_types]
|
|
|
|
def remove(self, item):
|
|
base_item = self.resource_type_proxy_helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.resource_type_proxy_helper.proxy(result)
|
|
|
|
|
|
class MetadefResourceType(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
namespace = _proxy('base', 'namespace')
|
|
name = _proxy('base', 'name')
|
|
prefix = _proxy('base', 'prefix')
|
|
properties_target = _proxy('base', 'properties_target')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
|
|
class MetadefResourceTypeFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
resource_type_proxy_class=None,
|
|
resource_type_proxy_kwargs=None):
|
|
self.resource_type_helper = Helper(resource_type_proxy_class,
|
|
resource_type_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_resource_type(self, **kwargs):
|
|
t = self.base.new_resource_type(**kwargs)
|
|
return self.resource_type_helper.proxy(t)
|
|
|
|
|
|
# Metadef namespace property classes
|
|
class MetadefPropertyRepo(object):
|
|
def __init__(self, base,
|
|
property_proxy_class=None, property_proxy_kwargs=None):
|
|
self.base = base
|
|
self.property_proxy_helper = Helper(property_proxy_class,
|
|
property_proxy_kwargs)
|
|
|
|
def get(self, namespace, property_name):
|
|
property = self.base.get(namespace, property_name)
|
|
return self.property_proxy_helper.proxy(property)
|
|
|
|
def add(self, property):
|
|
self.base.add(self.property_proxy_helper.unproxy(property))
|
|
|
|
def list(self, *args, **kwargs):
|
|
properties = self.base.list(*args, **kwargs)
|
|
return [self.property_proxy_helper.proxy(property) for property
|
|
in properties]
|
|
|
|
def remove(self, item):
|
|
base_item = self.property_proxy_helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.property_proxy_helper.proxy(result)
|
|
|
|
def save(self, item):
|
|
base_item = self.property_proxy_helper.unproxy(item)
|
|
result = self.base.save(base_item)
|
|
return self.property_proxy_helper.proxy(result)
|
|
|
|
|
|
class MetadefProperty(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
namespace = _proxy('base', 'namespace')
|
|
property_id = _proxy('base', 'property_id')
|
|
name = _proxy('base', 'name')
|
|
schema = _proxy('base', 'schema')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
|
|
class MetadefPropertyFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
property_proxy_class=None,
|
|
property_proxy_kwargs=None):
|
|
self.meta_object_helper = Helper(property_proxy_class,
|
|
property_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_namespace_property(self, **kwargs):
|
|
t = self.base.new_namespace_property(**kwargs)
|
|
return self.meta_object_helper.proxy(t)
|
|
|
|
|
|
# Metadef tag classes
|
|
class MetadefTagRepo(object):
|
|
def __init__(self, base,
|
|
tag_proxy_class=None, tag_proxy_kwargs=None):
|
|
self.base = base
|
|
self.tag_proxy_helper = Helper(tag_proxy_class,
|
|
tag_proxy_kwargs)
|
|
|
|
def get(self, namespace, name):
|
|
meta_tag = self.base.get(namespace, name)
|
|
return self.tag_proxy_helper.proxy(meta_tag)
|
|
|
|
def add(self, meta_tag):
|
|
self.base.add(self.tag_proxy_helper.unproxy(meta_tag))
|
|
|
|
def add_tags(self, meta_tags):
|
|
tags_list = []
|
|
for meta_tag in meta_tags:
|
|
tags_list.append(self.tag_proxy_helper.unproxy(meta_tag))
|
|
self.base.add_tags(tags_list)
|
|
|
|
def list(self, *args, **kwargs):
|
|
tags = self.base.list(*args, **kwargs)
|
|
return [self.tag_proxy_helper.proxy(meta_tag) for meta_tag
|
|
in tags]
|
|
|
|
def remove(self, item):
|
|
base_item = self.tag_proxy_helper.unproxy(item)
|
|
result = self.base.remove(base_item)
|
|
return self.tag_proxy_helper.proxy(result)
|
|
|
|
def save(self, item):
|
|
base_item = self.tag_proxy_helper.unproxy(item)
|
|
result = self.base.save(base_item)
|
|
return self.tag_proxy_helper.proxy(result)
|
|
|
|
|
|
class MetadefTag(object):
|
|
def __init__(self, base):
|
|
self.base = base
|
|
|
|
namespace = _proxy('base', 'namespace')
|
|
tag_id = _proxy('base', 'tag_id')
|
|
name = _proxy('base', 'name')
|
|
created_at = _proxy('base', 'created_at')
|
|
updated_at = _proxy('base', 'updated_at')
|
|
|
|
def delete(self):
|
|
self.base.delete()
|
|
|
|
|
|
class MetadefTagFactory(object):
|
|
def __init__(self,
|
|
base,
|
|
meta_tag_proxy_class=None,
|
|
meta_tag_proxy_kwargs=None):
|
|
self.meta_tag_helper = Helper(meta_tag_proxy_class,
|
|
meta_tag_proxy_kwargs)
|
|
self.base = base
|
|
|
|
def new_tag(self, **kwargs):
|
|
t = self.base.new_tag(**kwargs)
|
|
return self.meta_tag_helper.proxy(t)
|