sbcli-pre 1.2.5__zip → 1.2.6__zip

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/controllers/pool_controller.py

@@ -23,7 +23,7 @@ def _generate_string(length):
         string.ascii_letters + string.digits) for _ in range(length))
 
 
-def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, has_secret):
+def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, has_secret, cluster_id):
 
     if not name:
         logger.error("Pool name is empty!")
@@ -34,6 +34,11 @@ def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes,
             logger.error(f"Pool found with the same name: {name}")
             return False
 
+    cluster = db_controller.get_cluster_by_id(cluster_id)
+    if not cluster:
+        logger.error(f"Cluster not found: {cluster_id}")
+        return False
+
     pool_max = pool_max or 0
     lvol_max = lvol_max or 0
     max_rw_iops = max_rw_iops or 0
@@ -46,7 +51,6 @@ def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes,
             logger.error("max_rw_mbytes must be greater than max_w_mbytes and max_r_mbytes")
             return False
 
-    cluster = db_controller.get_clusters()[0]
     logger.info("Adding pool")
     pool = Pool()
     pool.id = str(uuid.uuid4())
@@ -136,8 +140,8 @@ def delete_pool(uuid):
     return True
 
 
-def list_pools(is_json):
-    pools = db_controller.get_pools()
+def list_pools(is_json, cluster_id=None):
+    pools = db_controller.get_pools(cluster_id)
     data = []
     for pool in pools:
         data.append({

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/controllers/snapshot_controller.py

@@ -49,7 +49,7 @@ def add(lvol_id, snapshot_name):
     ret = rpc_client.bdev_distrib_create(
         base_name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
         lvol.distr_bs, lvol_controller.get_jm_names(snode), lvol.distr_chunk_bs,
-        None, None, lvol.distr_page_size)
+        None, None, lvol.distr_page_size, dev_cpu_mask=snode.dev_cpu_mask)
     if not ret:
         logger.error("Failed to create Distr bdev")
         return False, "Failed to create Distr bdev"
@@ -119,7 +119,12 @@ def delete(snapshot_uuid):
         logger.error(f"Snapshot not found {snapshot_uuid}")
         return False
 
-    for lvol in db_controller.get_lvols():
+    snode = db_controller.get_storage_node_by_id(snap.lvol.node_id)
+    if not snode:
+        logger.error(f"Storage node not found {snap.lvol.node_id}")
+        return False
+
+    for lvol in db_controller.get_lvols(snode.cluster_id):
         if lvol.cloned_from_snap and lvol.cloned_from_snap == snapshot_uuid:
             logger.warning(f"Soft delete snapshot with clones, lvol ID: {lvol.get_id()}")
             snap.deleted = True
@@ -227,7 +232,8 @@ def clone(snapshot_id, clone_name, new_size=0):
     name = f"distr_{new_vuid}_1"
     ret = rpc_client.bdev_distrib_create(
         name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
-        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size)
+        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size,
+        dev_cpu_mask=snode.dev_cpu_mask)
     if not ret:
         msg="Failed to create Distr bdev"
         logger.error(msg)

sbcli_pre-1.2.6/simplyblock_core/controllers/tasks_controller.py

@@ -0,0 +1,103 @@
+# coding=utf-8
+import logging
+import time
+import uuid
+
+from simplyblock_core import kv_store, constants, utils
+from simplyblock_core.controllers import tasks_events
+from simplyblock_core.models.job_schedule import JobSchedule
+
+logger = logging.getLogger()
+db_controller = kv_store.DBController()
+
+
+def _validate_new_task_node_restart(cluster_id, node_id):
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        if task.function_name == JobSchedule.FN_NODE_RESTART and task.node_id == node_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+    return True
+
+
+def _validate_new_task_dev_restart(cluster_id, node_id, device_id):
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        if task.function_name == JobSchedule.FN_DEV_RESTART and task.device_id == device_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+        elif task.function_name == JobSchedule.FN_NODE_RESTART and task.node_id == node_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+    return True
+
+
+def _add_task(function_name, cluster_id, node_id, device_id):
+
+    if function_name in [JobSchedule.FN_DEV_RESTART, JobSchedule.FN_DEV_MIG]:
+        if not _validate_new_task_dev_restart(cluster_id, node_id, device_id):
+            return False
+    elif function_name == JobSchedule.FN_NODE_RESTART:
+        if not _validate_new_task_node_restart(cluster_id, node_id):
+            return False
+
+    task_obj = JobSchedule()
+    task_obj.uuid = str(uuid.uuid4())
+    task_obj.cluster_id = cluster_id
+    task_obj.node_id = node_id
+    task_obj.device_id = device_id
+    task_obj.date = int(time.time())
+    task_obj.function_name = function_name
+    task_obj.status = JobSchedule.STATUS_NEW
+    task_obj.write_to_db(db_controller.kv_store)
+    tasks_events.task_create(task_obj)
+    return task_obj.uuid
+
+
+def add_device_mig_task(device_id):
+    device = db_controller.get_storage_devices(device_id)
+    return _add_task(JobSchedule.FN_DEV_MIG, device.cluster_id, device.node_id, device.get_id())
+
+
+def add_device_to_auto_restart(device):
+    return _add_task(JobSchedule.FN_DEV_RESTART, device.cluster_id, device.node_id, device.get_id())
+
+
+def add_node_to_auto_restart(node):
+    return _add_task(JobSchedule.FN_NODE_RESTART, node.cluster_id, node.get_id(), "")
+
+
+def list_tasks(cluster_id):
+    cluster = db_controller.get_cluster_by_id(cluster_id)
+    if not cluster:
+        logger.error("Cluster not found: %s", cluster_id)
+        return False
+
+    data = []
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        data.append({
+            "Task ID": task.uuid,
+            "Target ID": task.device_id or task.node_id,
+            "Function": task.function_name,
+            "Retry": f"{task.retry}/{constants.TASK_EXEC_RETRY_COUNT}",
+            "Status": task.status,
+            "Result": task.function_result,
+            "Date": time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(task.date)),
+        })
+    return utils.print_table(data)
+
+
+def cancel_task(task_id):
+    task = db_controller.get_task_by_id(task_id)
+    if not task:
+        logger.error("Task not found: %s", task_id)
+        return False
+
+    task.canceled = True
+    task.write_to_db(db_controller.kv_store)
+    tasks_events.task_canceled(task)
+    return True

sbcli_pre-1.2.6/simplyblock_core/controllers/tasks_events.py

@@ -0,0 +1,37 @@
+# coding=utf-8
+import logging
+
+from simplyblock_core.controllers import events_controller as ec
+from simplyblock_core.kv_store import DBController
+
+logger = logging.getLogger()
+db_controller = DBController()
+
+
+def _task_event(task, message, caused_by, event):
+    ec.log_event_cluster(
+        cluster_id=task.cluster_id,
+        domain=ec.DOMAIN_CLUSTER,
+        event=event,
+        db_object=task,
+        caused_by=caused_by,
+        message=message,
+        node_id=task.node_id,
+        status=task.status)
+
+
+def task_create(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"task created: {task.uuid}", caused_by, ec.EVENT_OBJ_CREATED)
+
+
+def task_updated(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"Task updated: {task.uuid}", caused_by, ec.EVENT_STATUS_CHANGE)
+
+
+def task_status_change(task, new_state, old_status, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"task status changed from: {old_status} to: {new_state}", caused_by, ec.EVENT_STATUS_CHANGE)
+
+
+def task_canceled(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"Task canceled: {task.uuid}", caused_by, ec.EVENT_STATUS_CHANGE)
+

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/distr_controller.py

@@ -10,8 +10,9 @@ from simplyblock_core.kv_store import DBController
 logger = logging.getLogger()
 
 
-def send_node_status_event(node_id, node_status):
+def send_node_status_event(node, node_status):
     db_controller = DBController()
+    node_id = node.get_id()
     logging.info(f"Sending event updates, node: {node_id}, status: {node_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -20,7 +21,7 @@ def send_node_status_event(node_id, node_status):
         "status": node_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -29,8 +30,9 @@ def send_node_status_event(node_id, node_status):
         ret = rpc_client.distr_status_events_update(events)
 
 
-def send_dev_status_event(storage_ID, dev_status):
+def send_dev_status_event(device, dev_status):
     db_controller = DBController()
+    storage_ID = device.cluster_device_order
     logging.info(f"Sending event updates, device: {storage_ID}, status: {dev_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -39,7 +41,7 @@ def send_dev_status_event(storage_ID, dev_status):
         "status": dev_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -52,7 +54,7 @@ def send_dev_status_event(storage_ID, dev_status):
 
 def disconnect_device(device):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -95,7 +97,9 @@ def get_distr_cluster_map(snodes, target_node):
             dev_map[dev.cluster_device_order] = {
                 "UUID": dev.get_id(),
                 "bdev_name": name,
-                "status": dev.status}
+                "status": dev.status,
+                "physical_label": dev.physical_label
+            }
             dev_w_map.append({
                 "weight": dev_w,
                 "id": dev.cluster_device_order})
@@ -158,7 +162,7 @@ def parse_distr_cluster_map(map_string):
                 "Actual Status": "",
                 "Results": "",
             }
-            sd = db_controller.get_storage_devices(device_id)
+            sd = db_controller.get_storage_device_by_id(device_id)
             if sd:
                 data["Actual Status"] = sd.status
                 if sd.status == status:
@@ -175,7 +179,7 @@ def parse_distr_cluster_map(map_string):
 
 def send_cluster_map_to_node(node):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
     rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password)
     cluster_map_data = get_distr_cluster_map(snodes, node)
     cluster_map_data['UUID_node_target'] = node.get_id()
@@ -189,7 +193,7 @@ def send_cluster_map_to_node(node):
 
 def send_cluster_map_add_node(snode):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/kv_store.py

@@ -98,11 +98,19 @@ class DBController:
                 nodes.append(n)
         return sorted(nodes, key=lambda x: x.create_dt)
 
+    def get_storage_node_by_system_id(self, system_id):
+        nodes = StorageNode().read_from_db(self.kv_store)
+        for node in nodes:
+            if node.system_uuid == system_id:
+                return node
+        return None
+
     def get_storage_node_by_id(self, id):
         ret = StorageNode().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
 
+    # todo: change this function for multi cluster
     def get_caching_nodes(self):
         ret = CachingNode().read_from_db(self.kv_store)
         ret = sorted(ret, key=lambda x: x.create_dt)
@@ -113,6 +121,12 @@ class DBController:
         if ret:
             return ret[0]
 
+    def get_caching_node_by_system_id(self, system_id):
+        nodes = CachingNode().read_from_db(self.kv_store)
+        for node in nodes:
+            if node.system_uuid == system_id:
+                return node
+
     def get_caching_node_by_hostname(self, hostname):
         nodes = self.get_caching_nodes()
         for node in nodes:
@@ -125,20 +139,15 @@ class DBController:
             if node.hostname == hostname:
                 return node
 
-    def get_storage_devices(self, id=""):
-        # workaround because nvme devices are stored inside the node object itself.
+    def get_storage_device_by_id(self, id):
         nodes = self.get_storage_nodes()
-        devices = []
-        device = None
         for node in nodes:
-            if node.nvme_devices:
-                devices.extend(node.nvme_devices)
-                for dev in node.nvme_devices:
-                    if dev.get_id() == id:
-                        device = dev
-        if id:
-            return device
-        return devices
+            for dev in node.nvme_devices:
+                if dev.get_id() == id:
+                    return dev
+
+    def get_storage_devices(self, id):
+        return self.get_storage_device_by_id(id)
 
     # Compute node functions
     def get_compute_node_by_id(self, id):
@@ -150,9 +159,15 @@ class DBController:
         ret = ComputeNode().read_from_db(self.kv_store)
         return ret
 
-    def get_pools(self):
-        ret = Pool().read_from_db(self.kv_store)
-        return ret
+    def get_pools(self, cluster_id=None):
+        pools = []
+        if cluster_id:
+            for pool in Pool().read_from_db(self.kv_store):
+                if pool.cluster_id == cluster_id:
+                    pools.append(pool)
+        else:
+            pools = Pool().read_from_db(self.kv_store)
+        return pools
 
     def get_pool_by_id(self, id):
         ret = Pool().read_from_db(self.kv_store, id)
@@ -165,9 +180,16 @@ class DBController:
             if pool.pool_name == name:
                 return pool
 
-    def get_lvols(self):
-        ret = LVol().read_from_db(self.kv_store)
-        return ret
+    def get_lvols(self, cluster_id=None):
+        lvols = []
+        if cluster_id:
+            for pool in self.get_pools(cluster_id):
+                if pool.cluster_id == cluster_id:
+                    for lv_id in pool.lvols:
+                        lvols.append(self.get_lvol_by_id(lv_id))
+        else:
+            lvols = LVol().read_from_db(self.kv_store)
+        return lvols
 
     def get_snapshots(self):
         ret = SnapShot().read_from_db(self.kv_store)
@@ -259,5 +281,10 @@ class DBController:
     def get_events(self, event_id=""):
         return EventObj().read_from_db(self.kv_store, id=event_id)
 
-    def get_job_tasks(self, cluster_id):
-        return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=True)
+    def get_job_tasks(self, cluster_id, reverse=True):
+        return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=reverse)
+
+    def get_task_by_id(self, task_id):
+        for task in self.get_job_tasks(""):
+            if task.uuid == task_id:
+                return task

sbcli_pre-1.2.6/simplyblock_core/mgmt_node_ops.py

@@ -0,0 +1,205 @@
+# coding=utf-8
+import json
+import logging
+import uuid
+import time
+import requests
+
+import docker
+
+from simplyblock_core import utils, scripts
+from simplyblock_core.controllers import mgmt_events
+from simplyblock_core.kv_store import DBController
+from simplyblock_core.models.mgmt_node import MgmtNode
+
+
+logger = logging.getLogger()
+
+
+def deploy_mgmt_node(cluster_ip, cluster_id, ifname):
+
+    try:
+        resp = requests.get(f"http://{cluster_ip}/cluster/{cluster_id}")
+        resp_json = resp.json()
+        cluster_data = resp_json['results'][0]
+        logger.info(f"Cluster found! NQN:{cluster_data['nqn']}")
+        logger.debug(cluster_data)
+    except Exception as e:
+        logger.error("Error getting cluster data!")
+        logger.error(e)
+        return ""
+
+    logger.info("Installing dependencies...")
+    scripts.install_deps()
+    logger.info("Installing dependencies > Done")
+
+    if not ifname:
+        ifname = "eth0"
+
+    DEV_IP = utils.get_iface_ip(ifname)
+    if not DEV_IP:
+        logger.error(f"Error getting interface ip: {ifname}")
+        return False
+
+    logger.info(f"Node IP: {DEV_IP}")
+    ret = scripts.configure_docker(DEV_IP)
+
+    db_connection = cluster_data['db_connection']
+    scripts.set_db_config(db_connection)
+    time.sleep(1)
+    hostname = utils.get_hostname()
+    db_controller = DBController()
+    nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
+    if not nodes:
+        logger.error("No mgmt nodes was found in the cluster!")
+        return False
+    for node in nodes:
+        if node.hostname == hostname:
+            logger.error("Node already exists in the cluster")
+            return False
+
+    logger.info("Joining docker swarm...")
+    try:
+        cluster_docker = utils.get_docker_client(cluster_id)
+        docker_ip = cluster_docker.info()["Swarm"]["NodeAddr"]
+        join_token = cluster_docker.swarm.attrs['JoinTokens']['Manager']
+        node_docker = docker.DockerClient(base_url=f"tcp://{DEV_IP}:2375", version="auto")
+        if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
+            logger.info("Node is part of another swarm, leaving swarm")
+            try:
+                cluster_docker.nodes.get(node_docker.info()["Swarm"]["NodeID"]).remove(force=True)
+            except:
+                pass
+            node_docker.swarm.leave(force=True)
+            time.sleep(5)
+
+        node_docker.swarm.join([f"{docker_ip}:2377"], join_token)
+
+        retries = 10
+        while retries > 0:
+            if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
+                break
+            logger.info("Waiting for node to be active...")
+            retries -= 1
+            time.sleep(2)
+        logger.info("Joining docker swarm > Done")
+        time.sleep(5)
+
+    except Exception as e:
+        raise e
+
+    logger.info("Adding management node object")
+    node_id = add_mgmt_node(DEV_IP, cluster_id)
+
+    # check if ha setting is required
+    nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
+    if len(nodes) >= 3:
+        logger.info("Waiting for FDB container to be active...")
+        fdb_cont = None
+        retries = 30
+        while retries > 0 and fdb_cont is None:
+            logger.info("Looking for FDB container...")
+            for cont in node_docker.containers.list(all=True):
+                logger.debug(cont.attrs['Name'])
+                if cont.attrs['Name'].startswith("/app_fdb"):
+                    fdb_cont = cont
+                    break
+            if fdb_cont:
+                logger.info("FDB container found")
+                break
+            else:
+                retries -= 1
+                time.sleep(5)
+
+        if not fdb_cont:
+            logger.warning("FDB container was not found")
+        else:
+            retries = 10
+            while retries > 0:
+                info = node_docker.containers.get(fdb_cont.attrs['Id'])
+                status = info.attrs['State']["Status"]
+                is_running = info.attrs['State']["Running"]
+                if not is_running:
+                    logger.info("Container is not running, waiting...")
+                    time.sleep(3)
+                    retries -= 1
+                else:
+                    logger.info(f"Container status: {status}, Is Running: {is_running}")
+                break
+
+        logger.info("Configuring Double DB...")
+        time.sleep(3)
+        scripts.set_db_config_double()
+        for cl in db_controller.get_clusters():
+            cl.ha_type = "ha"
+            cl.write_to_db(db_controller.kv_store)
+
+    logger.info("Node joined the cluster")
+    return node_id
+
+
+def add_mgmt_node(mgmt_ip, cluster_id=None):
+    db_controller = DBController()
+    hostname = utils.get_hostname()
+    node = db_controller.get_mgmt_node_by_hostname(hostname)
+    if node:
+        logger.error("Node already exists in the cluster")
+        return False
+
+    node = MgmtNode()
+    node.uuid = str(uuid.uuid4())
+    node.hostname = hostname
+    node.docker_ip_port = f"{mgmt_ip}:2375"
+    node.cluster_id = cluster_id
+    node.mgmt_ip = mgmt_ip
+    node.status = MgmtNode.STATUS_ONLINE
+    node.write_to_db(db_controller.kv_store)
+
+    mgmt_events.mgmt_add(node)
+    logger.info("Done")
+    return node.uuid
+
+
+def list_mgmt_nodes(is_json):
+    db_controller = DBController()
+    nodes = db_controller.get_mgmt_nodes()
+    data = []
+    output = ""
+
+    for node in nodes:
+        logging.debug(node)
+        logging.debug("*" * 20)
+        data.append({
+            "UUID": node.get_id(),
+            "Hostname": node.hostname,
+            "IP": node.mgmt_ip,
+            "Status": node.status,
+        })
+
+    if not data:
+        return output
+
+    if is_json:
+        output = json.dumps(data, indent=2)
+    else:
+        output = utils.print_table(data)
+    return output
+
+
+def remove_mgmt_node(uuid):
+    db_controller = DBController()
+    snode = db_controller.get_mgmt_node_by_id(uuid)
+    if not snode:
+        logger.error("can not find node")
+        return False
+
+    logging.info("Removing mgmt node")
+    snode.remove(db_controller.kv_store)
+
+    logger.info("Leaving swarm...")
+    node_docker = docker.DockerClient(base_url=f"tcp://{snode.docker_ip_port}", version="auto")
+    node_docker.swarm.leave()
+
+    mgmt_events.mgmt_remove(snode)
+    logging.info("done")
+

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/models/events.py

@@ -1,4 +1,6 @@
 # coding=utf-8
+from datetime import datetime
+
 from simplyblock_core.models.base_model import BaseModel
 
 
@@ -25,7 +27,7 @@ class EventObj(BaseModel):
         "uuid": {"type": str, 'default': ""},
         "cluster_uuid": {"type": str, 'default': ""},
         "node_id": {"type": str, 'default': ""},
-        "date": {"type": int, 'default': 0},
+        "date": {"type": int, 'default': 0},  # in milliseconds
 
         "event_level": {"type": str, 'default': LEVEL_INFO},
 
@@ -49,3 +51,9 @@ class EventObj(BaseModel):
 
     def get_id(self):
         return "%s/%s/%s" % (self.cluster_uuid, self.date, self.uuid)
+
+    def get_date_string(self):
+        if self.date > 1e10:
+            return str(datetime.fromtimestamp(self.date/1000))
+        else:
+            return str(datetime.fromtimestamp(self.date))

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/models/job_schedule.py

@@ -8,6 +8,10 @@ class JobSchedule(BaseModel):
     STATUS_RUNNING = 'running'
     STATUS_DONE = 'done'
 
+    FN_DEV_RESTART = "device_restart"
+    FN_NODE_RESTART = "node_restart"
+    FN_DEV_MIG = "device_migration"
+
     attributes = {
         "uuid": {"type": str, 'default': ""},
         "cluster_id": {"type": str, 'default': ""},
@@ -15,6 +19,8 @@ class JobSchedule(BaseModel):
         "device_id": {"type": str, 'default': ""},
         "date": {"type": int, 'default': 0},
 
+        "canceled": {"type": bool, 'default': False},
+
         "function_name": {"type": str, 'default': ""},
         "function_params": {"type": dict, 'default': {}},
         "function_result": {"type": str, 'default': ""},