From baa916d5ec7b99a13519b3af7f1b528ea9cc83a7 Mon Sep 17 00:00:00 2001 From: Priyanka Agrawal Date: Mon, 9 Dec 2013 14:18:17 +0530 Subject: [PATCH] StackTach DB API Models initial check in * Used by the client to describe the data being returned by the API * Renamed Launch, Delete, Exist to ServerLaunch, ServerDelete, ServerExist respectively Change-Id: I5e8cc7cd41ac16aba0daf5d3dfef61dcbbaa4e07 --- .../stacktach/stacktach_db_api/client.py | 6 +- .../stacktach_db_api/models/__init__.py | 15 ++ .../models/stacktach_db_api.py | 213 ++++++++++++++++++ 3 files changed, 231 insertions(+), 3 deletions(-) create mode 100644 cloudcafe/stacktach/stacktach_db_api/models/__init__.py create mode 100644 cloudcafe/stacktach/stacktach_db_api/models/stacktach_db_api.py diff --git a/cloudcafe/stacktach/stacktach_db_api/client.py b/cloudcafe/stacktach/stacktach_db_api/client.py index 3b42b6eb..4eb57418 100644 --- a/cloudcafe/stacktach/stacktach_db_api/client.py +++ b/cloudcafe/stacktach/stacktach_db_api/client.py @@ -17,9 +17,9 @@ limitations under the License. from cafe.engine.clients.rest import AutoMarshallingRestClient from cloudcafe.stacktach.stacktach_db_api.models.stacktach_db_api import \ - (Launches as ResponseLaunch, - Deletes as ResponseDelete, - Exists as ResponseExist) + (ServerLaunches as ResponseLaunch, + ServerDeletes as ResponseDelete, + ServerExists as ResponseExist) class StackTachDBClient(AutoMarshallingRestClient): diff --git a/cloudcafe/stacktach/stacktach_db_api/models/__init__.py b/cloudcafe/stacktach/stacktach_db_api/models/__init__.py new file mode 100644 index 00000000..59ab77fa --- /dev/null +++ b/cloudcafe/stacktach/stacktach_db_api/models/__init__.py @@ -0,0 +1,15 @@ +""" +Copyright 2013 Rackspace + +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. +""" diff --git a/cloudcafe/stacktach/stacktach_db_api/models/stacktach_db_api.py b/cloudcafe/stacktach/stacktach_db_api/models/stacktach_db_api.py new file mode 100644 index 00000000..28a711f2 --- /dev/null +++ b/cloudcafe/stacktach/stacktach_db_api/models/stacktach_db_api.py @@ -0,0 +1,213 @@ +""" +Copyright 2013 Rackspace + +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. +""" + +import json + +from cafe.engine.models.base import \ + AutoMarshallingModel, AutoMarshallingListModel + + +class ServerLaunch(AutoMarshallingModel): + + def __init__(self, os_distro=None, os_version=None, instance_type_id=None, + instance_flavor_id=None, launched_at=None, instance=None, + os_architecture=None, request_id=None, rax_options=None, + id_=None, tenant=None): + + """An object that represents a Server Launch in Stacktach DB.""" + super(ServerLaunch, self).__init__() + self.os_distro = os_distro + self.os_version = os_version + self.instance_type_id = instance_type_id + self.instance_flavor_id = instance_flavor_id + self.launched_at = launched_at + self.instance = instance + self.os_architecture = os_architecture + self.request_id = request_id + self.rax_options = rax_options + self.id_ = id_ + self.tenant = tenant + + def __repr__(self): + values = [] + for prop, value in self.__dict__.items(): + values.append("{0}: {1}".format(prop, value)) + return "launch: [{0}]".format(', '.join(values)) + + @classmethod + def _json_to_obj(cls, serialized_str): + """ + Returns an instance of a Launch based on the json serialized_str + passed in. + """ + json_dict = json.loads(serialized_str) + launch = cls._dict_to_obj(json_dict['launch']) + return launch + + @classmethod + def _dict_to_obj(cls, launch_dict): + """ + Helper method to turn dictionary into Launch instance. + """ + if 'id' in launch_dict: + launch_dict['id_'] = launch_dict.pop('id') + launch = ServerLaunch(**launch_dict) + return launch + + +class ServerLaunches(AutoMarshallingListModel): + + @classmethod + def _json_to_obj(cls, serialized_string): + json_dict = json.loads(serialized_string) + return cls._list_to_obj(json_dict.get('launches')) + + @classmethod + def _list_to_obj(cls, launch_dict_list): + launches = ServerLaunches() + launches.extend([ServerLaunch._dict_to_obj(launch) + for launch in launch_dict_list]) + return launches + + +class ServerDelete(AutoMarshallingModel): + def __init__(self, raw=None, instance=None, deleted_at=None, id_=None, + launched_at=None): + """An object that represents a Server Delete in Stacktach DB. """ + super(ServerDelete, self).__init__() + self.raw = raw + self.instance = instance + self.deleted_at = deleted_at + self.id_ = id_ + self.launched_at = launched_at + + def __repr__(self): + values = [] + for prop, value in self.__dict__.items(): + values.append("{0}: {1}".format(prop, value)) + return "delete: [{0}]".format(', '.join(values)) + + @classmethod + def _json_to_obj(cls, serialized_str): + """ + Returns an instance of a Delete based on the json serialized_str + passed in. + """ + json_dict = json.loads(serialized_str) + delete = cls._dict_to_obj(json_dict['delete']) + return delete + + @classmethod + def _dict_to_obj(cls, delete_dict): + """ + Helper method to turn dictionary into Delete instance. + """ + if 'id' in delete_dict: + delete_dict['id_'] = delete_dict.pop('id') + delete = ServerDelete(**delete_dict) + return delete + + +class ServerDeletes(AutoMarshallingListModel): + + @classmethod + def _json_to_obj(cls, serialized_string): + json_dict = json.loads(serialized_string) + return cls._list_to_obj(json_dict.get('deletes')) + + @classmethod + def _list_to_obj(cls, delete_dict_list): + deletes = ServerDeletes() + deletes.extend([ServerDelete._dict_to_obj(delete) + for delete in delete_dict_list]) + return deletes + + +class ServerExist(AutoMarshallingModel): + def __init__(self, status=None, os_distro=None, bandwidth_public_out=None, + received=None, instance_type_id=None, raw=None, + os_architecture=None, rax_options=None, deleted_at=None, + audit_period_beginning=None, audit_period_ending=None, + id_=None, tenant=None, fail_reason=None, instance=None, + instance_flavor_id=None, os_version=None, launched_at=None, + usage=None, message_id=None, send_status=None, delete=None): + """ + An object that represents a Server Exist in Stacktach DB. + + """ + self.status = status + self.audit_period_beginning = audit_period_beginning + self.os_distro = os_distro + self.bandwidth_public_out = bandwidth_public_out + self.usage = usage + self.fail_reason = fail_reason + self.raw = raw + self.message_id = message_id + self.received = received + self.instance_type_id = instance_type_id + self.instance_flavor_id = instance_flavor_id + self.os_version = os_version + self.launched_at = launched_at + self.instance = instance + self.os_architecture = os_architecture + self.audit_period_ending = audit_period_ending + self.rax_options = rax_options + self.deleted_at = deleted_at + self.send_status = send_status + self.id_ = id_ + self.tenant = tenant + self.delete = delete + + def __repr__(self): + values = [] + for prop, value in self.__dict__.items(): + values.append("{0}: {1}".format(prop, value)) + return "exist: [{0}]".format(', '.join(values)) + + @classmethod + def _json_to_obj(cls, serialized_str): + """ + Returns an instance of an Exist based on the json serialized_str + passed in. + """ + json_dict = json.loads(serialized_str) + exist = cls._dict_to_obj(json_dict['exist']) + return exist + + @classmethod + def _dict_to_obj(cls, exist_dict): + """ + Helper method to turn dictionary into Exist instance. + """ + if 'id' in exist_dict: + exist_dict['id_'] = exist_dict.pop('id') + exist = ServerExist(**exist_dict) + return exist + + +class ServerExists(AutoMarshallingListModel): + + @classmethod + def _json_to_obj(cls, serialized_string): + json_dict = json.loads(serialized_string) + return cls._list_to_obj(json_dict.get('exists')) + + @classmethod + def _list_to_obj(cls, exist_dict_list): + exists = ServerExists() + exists.extend([ServerExist._dict_to_obj(exist) + for exist in exist_dict_list]) + return exists