sla/slaclient/wsag_model.py

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