X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_policy_module%2Fcore%2Fdatabase.py;h=b7a0b4f765a93451d3c5fc5ec5a29afdec1ec9ef;hb=3fbf2fbf60e3aed3ec7ca0134839f19bc0d733d4;hp=8ad19f2f4ecbe928fad165a921e1cceaa368be4a;hpb=d8e91c539f8a1657a93c6ed59dd5f9ad489684ef;p=osm%2FPOL.git

diff --git a/osm_policy_module/core/database.py b/osm_policy_module/core/database.py
index 8ad19f2..b7a0b4f 100644
--- a/osm_policy_module/core/database.py
+++ b/osm_policy_module/core/database.py
@@ -23,16 +23,29 @@
 ##
 import datetime
 import logging
-
-from peewee import CharField, IntegerField, ForeignKeyField, Model, TextField, AutoField, DateTimeField
-from playhouse.sqlite_ext import SqliteExtDatabase
-
+import os
+from typing import Iterable, List
+
+from peewee import (
+    CharField,
+    IntegerField,
+    ForeignKeyField,
+    Model,
+    TextField,
+    AutoField,
+    DateTimeField,
+    Proxy,
+    BooleanField,
+)
+from peewee_migrate import Router
+from playhouse.db_url import connect
+
+from osm_policy_module import migrations
 from osm_policy_module.core.config import Config
 
 log = logging.getLogger(__name__)
-cfg = Config.instance()
 
-db = SqliteExtDatabase('policy_module.db')
+db = Proxy()
 
 
 class BaseModel(Model):
@@ -44,7 +57,7 @@ class BaseModel(Model):
 
 class ScalingGroup(BaseModel):
     nsr_id = CharField()
-    vnf_member_index = IntegerField()
+    vnf_member_index = CharField()
     name = CharField()
     content = TextField()
 
@@ -52,28 +65,162 @@ class ScalingGroup(BaseModel):
 class ScalingPolicy(BaseModel):
     name = CharField()
     cooldown_time = IntegerField()
+    scale_in_operation = CharField(default="AND")
+    scale_out_operation = CharField(default="OR")
+    enabled = BooleanField(default=True)
     last_scale = DateTimeField(default=datetime.datetime.now)
-    scaling_group = ForeignKeyField(ScalingGroup, related_name='scaling_policies')
+    scaling_group = ForeignKeyField(
+        ScalingGroup, related_name="scaling_policies", on_delete="CASCADE"
+    )
 
 
 class ScalingCriteria(BaseModel):
     name = CharField()
-    scaling_policy = ForeignKeyField(ScalingPolicy, related_name='scaling_criterias')
+    scaling_policy = ForeignKeyField(
+        ScalingPolicy, related_name="scaling_criterias", on_delete="CASCADE"
+    )
 
 
 class ScalingAlarm(BaseModel):
-    alarm_id = CharField()
+    alarm_uuid = CharField(unique=True)
     action = CharField()
-    vnf_member_index = IntegerField()
+    vnf_member_index = CharField()
+    vdu_name = CharField()
+    scaling_criteria = ForeignKeyField(
+        ScalingCriteria, related_name="scaling_alarms", on_delete="CASCADE"
+    )
+    last_status = CharField(default="insufficient-data")
+
+
+class VnfAlarm(BaseModel):
+    alarm_id = CharField()
+    alarm_uuid = CharField(unique=True)
+    nsr_id = CharField()
+    vnf_member_index = CharField()
     vdu_name = CharField()
-    scaling_criteria = ForeignKeyField(ScalingCriteria, related_name='scaling_alarms')
+    last_action = CharField(default='insufficient-data')
+    id_suffix = IntegerField()
+    ok_ack = BooleanField(default=False)
+    alarm_ack = BooleanField(default=False)
+
+
+class AlarmAction(BaseModel):
+    type = CharField()
+    url = TextField()
+    alarm = ForeignKeyField(VnfAlarm, related_name="actions", on_delete="CASCADE")
 
 
 class DatabaseManager:
-    def create_tables(self):
-        try:
-            db.connect()
-            db.create_tables([ScalingGroup, ScalingPolicy, ScalingCriteria, ScalingAlarm])
-            db.close()
-        except Exception as e:
-            log.exception("Error creating tables: ")
+    def __init__(self, config: Config):
+        db.initialize(connect(config.get("sql", "database_uri")))
+
+    def create_tables(self) -> None:
+        db.connect()
+        with db.atomic():
+            router = Router(db, os.path.dirname(migrations.__file__))
+            router.run()
+        db.close()
+
+
+class ScalingAlarmRepository:
+    @staticmethod
+    def list(*expressions) -> Iterable[ScalingAlarm]:
+        return ScalingAlarm.select().where(*expressions)
+
+    @staticmethod
+    def get(*expressions, join_classes: List = None) -> ScalingAlarm:
+        query = ScalingAlarm.select()
+        if join_classes:
+            for join_class in join_classes:
+                query = query.join(join_class)
+        return query.where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> ScalingAlarm:
+        return ScalingAlarm.create(**query)
+
+
+class ScalingGroupRepository:
+    @staticmethod
+    def list(*expressions) -> Iterable[ScalingGroup]:
+        return ScalingGroup.select().where(*expressions)
+
+    @staticmethod
+    def get(*expressions) -> ScalingGroup:
+        return ScalingGroup.select().where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> ScalingGroup:
+        return ScalingGroup.create(**query)
+
+
+class ScalingPolicyRepository:
+    @staticmethod
+    def list(*expressions, join_classes: List = None) -> Iterable[ScalingPolicy]:
+        query = ScalingPolicy.select()
+        if join_classes:
+            for join_class in join_classes:
+                query = query.join(join_class)
+        return query.where(*expressions)
+
+    @staticmethod
+    def get(*expressions, join_classes: List = None) -> ScalingPolicy:
+        query = ScalingPolicy.select()
+        if join_classes:
+            for join_class in join_classes:
+                query = query.join(join_class)
+        return query.where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> ScalingPolicy:
+        return ScalingPolicy.create(**query)
+
+
+class ScalingCriteriaRepository:
+    @staticmethod
+    def list(*expressions, join_classes: List = None) -> Iterable[ScalingCriteria]:
+        query = ScalingCriteria.select()
+        if join_classes:
+            for join_class in join_classes:
+                query = query.join(join_class)
+        return query.where(*expressions)
+
+    @staticmethod
+    def get(*expressions, join_classes: List = None) -> ScalingCriteria:
+        query = ScalingCriteria.select()
+        if join_classes:
+            for join_class in join_classes:
+                query = query.join(join_class)
+        return query.where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> ScalingCriteria:
+        return ScalingCriteria.create(**query)
+
+
+class VnfAlarmRepository:
+    @staticmethod
+    def list(*expressions) -> Iterable[VnfAlarm]:
+        return VnfAlarm.select().where(*expressions)
+
+    @staticmethod
+    def get(*expressions) -> VnfAlarm:
+        return VnfAlarm.select().where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> VnfAlarm:
+        return VnfAlarm.create(**query)
+
+
+class AlarmActionRepository:
+    @staticmethod
+    def list(*expressions) -> Iterable[AlarmAction]:
+        return AlarmAction.select().where(*expressions)
+
+    @staticmethod
+    def get(*expressions) -> AlarmAction:
+        return AlarmAction.select().where(*expressions).get()
+
+    @staticmethod
+    def create(**query) -> AlarmAction:
+        return AlarmAction.create(**query)