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