import logging.handlers
import getopt
import sys
-import ROclient
-import ns
-import vim_sdn
-import netslice
+
+from osm_lcm import ROclient, ns, vim_sdn, netslice
from time import time, sleep
-from lcm_utils import versiontuple, LcmException, TaskRegistry, LcmExceptionExit
+from osm_lcm.lcm_utils import versiontuple, LcmException, TaskRegistry, LcmExceptionExit
+from osm_lcm import version as lcm_version, version_date as lcm_version_date
-# from osm_lcm import version as lcm_version, version_date as lcm_version_date, ROclient
from osm_common import dbmemory, dbmongo, fslocal, msglocal, msgkafka
from osm_common import version as common_version
from osm_common.dbbase import DbException
__author__ = "Alfonso Tierno"
-min_RO_version = [0, 6, 3]
+min_RO_version = "6.0.2"
min_n2vc_version = "0.0.2"
min_common_version = "0.1.19"
# uncomment if LCM is installed as library and installed, and get them from __init__.py
-lcm_version = '0.1.37'
-lcm_version_date = '2019-04-30'
+# lcm_version = '0.1.41'
+# lcm_version_date = '2019-06-19'
health_check_file = path.expanduser("~") + "/time_last_ping" # TODO find better location for this file
self.consecutive_errors = 0
self.first_start = False
- # contains created tasks/futures to be able to cancel
- self.lcm_tasks = TaskRegistry()
# logging
self.logger = logging.getLogger('lcm')
# get id
self.logger.critical(str(e), exc_info=True)
raise LcmException(str(e))
+ # contains created tasks/futures to be able to cancel
+ self.lcm_tasks = TaskRegistry(self.worker_id, self.db, self.logger)
+
self.ns = ns.NsLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config, self.vca_config, self.loop)
self.netslice = netslice.NetsliceLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config,
self.vca_config, self.loop)
self.sdn = vim_sdn.SdnLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config, self.loop)
async def check_RO_version(self):
- try:
- RO = ROclient.ROClient(self.loop, **self.ro_config)
- RO_version = await RO.get_version()
- if RO_version < min_RO_version:
- raise LcmException("Not compatible osm/RO version '{}.{}.{}'. Needed '{}.{}.{}' or higher".format(
- *RO_version, *min_RO_version
- ))
- except ROclient.ROClientException as e:
- error_text = "Error while conneting to osm/RO " + str(e)
- self.logger.critical(error_text, exc_info=True)
- raise LcmException(error_text)
+ tries = 14
+ last_error = None
+ while True:
+ try:
+ ro_server = ROclient.ROClient(self.loop, **self.ro_config)
+ ro_version = await ro_server.get_version()
+ if versiontuple(ro_version) < versiontuple(min_RO_version):
+ raise LcmException("Not compatible osm/RO version '{}'. Needed '{}' or higher".format(
+ ro_version, min_RO_version))
+ self.logger.info("Connected to RO version {}".format(ro_version))
+ return
+ except ROclient.ROClientException as e:
+ tries -= 1
+ error_text = "Error while connecting to RO on {}: {}".format(self.ro_config["endpoint_url"], e)
+ if tries <= 0:
+ self.logger.critical(error_text)
+ raise LcmException(error_text)
+ if last_error != error_text:
+ last_error = error_text
+ self.logger.error(error_text + ". Waiting until {} seconds".format(5*tries))
+ await asyncio.sleep(5)
async def test(self, param=None):
self.logger.debug("Starting/Ending test task: {}".format(param))
return
elif topic == "vim_account":
vim_id = params["_id"]
- if command == "create":
+ if command in ("create", "created"):
task = asyncio.ensure_future(self.vim.create(params, order_id))
self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_create", task)
return
elif command == "delete":
self.lcm_tasks.cancel(topic, vim_id)
- task = asyncio.ensure_future(self.vim.delete(vim_id, order_id))
+ task = asyncio.ensure_future(self.vim.delete(params, order_id))
self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_delete", task)
return
elif command == "show":
print("not implemented show with vim_account")
sys.stdout.flush()
return
- elif command == "edit":
+ elif command in ("edit", "edited"):
task = asyncio.ensure_future(self.vim.edit(params, order_id))
self.lcm_tasks.register("vim_account", vim_id, order_id, "vim_edit", task)
return
+ elif command == "deleted":
+ return # TODO cleaning of task just in case should be done
elif topic == "wim_account":
wim_id = params["_id"]
- if command == "create":
+ if command in ("create", "created"):
task = asyncio.ensure_future(self.wim.create(params, order_id))
self.lcm_tasks.register("wim_account", wim_id, order_id, "wim_create", task)
return
elif command == "delete":
self.lcm_tasks.cancel(topic, wim_id)
- task = asyncio.ensure_future(self.wim.delete(wim_id, order_id))
+ task = asyncio.ensure_future(self.wim.delete(params, order_id))
self.lcm_tasks.register("wim_account", wim_id, order_id, "wim_delete", task)
return
elif command == "show":
print("not implemented show with wim_account")
sys.stdout.flush()
return
- elif command == "edit":
+ elif command in ("edit", "edited"):
task = asyncio.ensure_future(self.wim.edit(params, order_id))
self.lcm_tasks.register("wim_account", wim_id, order_id, "wim_edit", task)
return
+ elif command == "deleted":
+ return # TODO cleaning of task just in case should be done
elif topic == "sdn":
_sdn_id = params["_id"]
- if command == "create":
+ if command in ("create", "created"):
task = asyncio.ensure_future(self.sdn.create(params, order_id))
self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_create", task)
return
elif command == "delete":
self.lcm_tasks.cancel(topic, _sdn_id)
- task = asyncio.ensure_future(self.sdn.delete(_sdn_id, order_id))
+ task = asyncio.ensure_future(self.sdn.delete(params, order_id))
self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_delete", task)
return
- elif command == "edit":
+ elif command in ("edit", "edited"):
task = asyncio.ensure_future(self.sdn.edit(params, order_id))
self.lcm_tasks.register("sdn", _sdn_id, order_id, "sdn_edit", task)
return
+ elif command == "deleted":
+ return # TODO cleaning of task just in case should be done
self.logger.critical("unknown topic {} and command '{}'".format(topic, command))
async def kafka_read(self):
projects / osm / LCM.git / blobdiff