sla/slaclient/wsag_model.py

   1 from datetime import datetime
   2 from dateutil import tz
   3 import dateutil.parser
   4
   5 """Contains the bean models for the SlaManager xml/json types
   6 """
   7
   8
   9 class Agreement(object):
  10
  11     class Context(object):
  12         def __init__(self):
  13             self.expirationtime = datetime.now()
  14             self.service = ""
  15             self.initiator = ""
  16             self.responder = ""
  17             self.provider = ""
  18             self.consumer = ""
  19
  20         def __repr__(self):
  21             s = "<Context(" + \
  22                 "expirationtime={}, provider={}, consumer={}, service={})>"
  23             return s.format(
  24                 repr(self.expirationtime),
  25                 repr(self.provider),
  26                 repr(self.consumer),
  27                 repr(self.service))
  28
  29         def service_formatted(self):
  30             return self.service.replace('_', ' ')
  31
  32         def testbed_formatted(self):
  33             return self.template_id.replace('Service', ' - ')
  34
  35         def time_formatted(self):
  36             from_zone = tz.tzutc()
  37             to_zone = tz.tzlocal()
  38             time = dateutil.parser.parse(self.expirationtime)
  39             time = time.replace(tzinfo=from_zone)
  40             time = time.astimezone(to_zone)
  41             return time.strftime('%d-%m-%Y at %H:%M:%S')
  42
  43     class Property(object):
  44         def __init__(self):
  45             self.servicename = ""
  46             self.name = ""
  47             self.metric = ""
  48             self.location = ""
  49
  50         def __repr__(self):
  51             str_ = "<Property(name={}, servicename={}, \
  52                     metric={}, location={})>"
  53             return str_.format(
  54                 repr(self.name),
  55                 repr(self.servicename),
  56                 repr(self.metric),
  57                 repr(self.location))
  58
  59     class GuaranteeTerm(object):
  60
  61         class GuaranteeScope(object):
  62             def __init__(self):
  63                 self.servicename = ""
  64                 self.scope = ""
  65
  66             def __repr__(self):
  67                 return "<GuaranteeScope(servicename={}, scope={}>)".format(
  68                     repr(self.servicename),
  69                     repr(self.scope)
  70                 )
  71
  72         class ServiceLevelObjective(object):
  73             def __init__(self):
  74                 self.kpiname = ""
  75                 self.customservicelevel = ""
  76
  77             def __repr__(self):
  78                 s = "<ServiceLevelObjective(kpiname={}, \
  79                     customservicelevel={})>"
  80                 return s.format(
  81                     repr(self.kpiname),
  82                     repr(self.customservicelevel)
  83                 )
  84
  85         def __init__(self):
  86             self.name = ""
  87             self.scopes = []        # item: GuaranteeScope
  88             """:type : list[Agreement.GuaranteeTerm.GuaranteeScope]"""
  89             self.servicelevelobjective = \
  90                 Agreement.GuaranteeTerm.ServiceLevelObjective()
  91
  92         def __repr__(self):
  93             s = "<GuaranteeTerm(scopes={}, servicelevelobjective={})>"
  94             return s.format(
  95                 repr(self.scopes),
  96                 repr(self.servicelevelobjective)
  97             )
  98
  99     def __init__(self):
 100         """Simple bean model for a ws-agreement agreement/template
 101         """
 102         self.context = Agreement.Context()
 103         self.agreement_id = ""
 104         self.descriptionterms = {}
 105         self.variables = {}         # key: Property.name / value: Property
 106         """:type : dict[str,Agreement.Property]"""
 107         self.guaranteeterms = {}    # key: GT.name / value: GT
 108         """:type : dict[str,Agreement.GuaranteeTerm]"""
 109
 110     def __repr__(self):
 111         s = ("<Agreement(agreement_id={}, context={}, descriptionterms={}, " +
 112              "variables={}, guaranteeterms={}>")
 113         return s.format(
 114             repr(self.agreement_id),
 115             repr(self.context),
 116             repr(self.descriptionterms),
 117             repr(self.variables),
 118             repr(self.guaranteeterms)
 119         )
 120
 121
 122 class Template(Agreement):
 123     def __init__(self):
 124         super(Template, self).__init__()
 125         self.template_id = ""
 126
 127     def __repr__(self):
 128         s = ("<Template(template_id={}, context={}, descriptionterms={}, " +
 129              "variables={}, guaranteeterms={}>")
 130         return s.format(
 131             repr(self.template_id),
 132             repr(self.context),
 133             repr(self.descriptionterms),
 134             repr(self.variables),
 135             repr(self.guaranteeterms)
 136         )
 137
 138
 139 class Enforcement(object):
 140     def __init__(self):
 141         """Simple bean model for an enforcement"""
 142         self.agreement_id = ""
 143         self.enabled = ""
 144
 145     def __repr__(self):
 146         return ("<Enforcement(agreement_id={}, enabled={})>".format(
 147                 self.agreement_id,
 148                 self.enabled)
 149                 )
 150
 151
 152 class AgreementStatus(object):
 153
 154     class StatusEnum:
 155         VIOLATED = "VIOLATED"
 156         FULFILLED = "FULFILLED"
 157         NON_DETERMINED = "NON_DETERMINED"
 158
 159     class GuaranteeTermStatus(object):
 160         def __init__(self):
 161             self.name = ""
 162             self.status = ""
 163
 164         def __repr__(self):
 165             s = "<GuaranteeTermStatus(name='{}' status='{}')>"
 166             return s.format(self.name, self.status)
 167
 168     def __init__(self):
 169         self.agreement_id = ""
 170         self.guaranteestatus = ""
 171         self.guaranteeterms = []
 172
 173     def __repr__(self):
 174         return (
 175             "<AgreementStatus( agreement_id={}, guaranteestatus={}, " +
 176             "guaranteeterms={})>").format(
 177             self.agreement_id,
 178             self.guaranteestatus,
 179             repr(self.guaranteeterms))
 180
 181     @staticmethod
 182     def json_decode(json_obj):
 183         o = AgreementStatus()
 184         o.agreement_id = json_obj["AgreementId"]
 185         o.guaranteestatus = json_obj["guaranteestatus"]
 186
 187         for term in json_obj["guaranteeterms"]:
 188             t = AgreementStatus.GuaranteeTermStatus()
 189             t.name = term["name"]
 190             t.status = term["status"]
 191             o.guaranteeterms.append(t)
 192         return o
 193
 194
 195 class Violation(object):
 196     def __init__(self):
 197         """Simple bean model for a violation"""
 198         self.uuid = ""
 199         self.contract_uuid = ""
 200         self.service_scope = ""
 201         self.service_name = ""
 202         self.metric_name = ""
 203         self.datetime = datetime.utcnow()
 204         self.actual_value = 0
 205
 206     def __repr__(self):
 207         return ("<Violation(uuid={}, datetime={}, contract_uuid={}, \
 208                 service_name={}, service_scope={}, metric_name={}, \
 209                 actual_value={})>\n".format(
 210                 self.uuid,
 211                 self.datetime,
 212                 self.contract_uuid,
 213                 self.service_name,
 214                 self.service_scope,
 215                 self.metric_name,
 216                 self.actual_value)
 217                 )
 218
 219     def format_time(self):
 220         # return str(datetime.fromtimestamp(self.datetime))
 221         return str(self.datetime)
 222
 223
 224 class Provider(object):
 225     def __init__(self):
 226         """Simple bean model for a provider"""
 227         self.uuid = ""
 228         self.name = ""
 229
 230     def __repr__(self):
 231         return ("<Provider(uuid={}, name={})>".format(
 232                 self.uuid,
 233                 self.name)
 234                 )
 235
 236     def to_xml(self):
 237         xml = "<provider><uuid>{}</uuid><name>{}</name></provider>""".format(
 238             self.uuid,
 239             self.name
 240         )
 241         return xml
 242
 243     @staticmethod
 244     def from_dict(d):
 245         """Creates a Provider object from a dict structure (e.g.
 246         a deserialized json string)
 247
 248         Usage:
 249         json_obj = json.loads(json_data)
 250         out = wsag_model.Provider.from_dict(json_obj)
 251         """
 252         result = Provider(d["uuid"], d["name"])
 253         return result