from osm_lcm import ns
from osm_lcm import vim_sdn
from osm_lcm import netslice
-from osm_lcm import ROclient
+from osm_lcm.ng_ro import NgRoException, NgRoClient
+from osm_lcm.ROclient import ROClient, ROClientException
-from time import time, sleep
+from time import time
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_common import dbmemory, dbmongo, fslocal, msglocal, msgkafka
+from osm_common import dbmemory, dbmongo, fslocal, fsmongo, msglocal, msgkafka
from osm_common import version as common_version
from osm_common.dbbase import DbException
from osm_common.fsbase import FsException
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.41'
-# lcm_version_date = '2019-06-19'
health_check_file = path.expanduser("~") + "/time_last_ping" # TODO find better location for this file
:param config: two level dictionary with configuration. Top level should contain 'database', 'storage',
:return: None
"""
-
self.db = None
self.msg = None
self.msg_admin = None
# load configuration
config = self.read_config_file(config_file)
self.config = config
- self.ro_config = {
- "endpoint_url": "http://{}:{}/openmano".format(config["RO"]["host"], config["RO"]["port"]),
+ self.config["ro_config"] = {
+ "ng": config["RO"].get("ng", False),
+ "uri": config["RO"].get("uri"),
"tenant": config.get("tenant", "osm"),
- "logger_name": "lcm.ROclient",
- "loglevel": "ERROR",
+ "logger_name": "lcm.roclient",
+ "loglevel": config["RO"].get("loglevel", "ERROR"),
}
-
- self.vca_config = config["VCA"]
+ if not self.config["ro_config"]["uri"]:
+ if not self.config["ro_config"]["ng"]:
+ self.config["ro_config"]["uri"] = "http://{}:{}/openmano".format(config["RO"]["host"],
+ config["RO"]["port"])
+ else:
+ self.config["ro_config"]["uri"] = "http://{}:{}/ro".format(config["RO"]["host"], config["RO"]["port"])
self.loop = loop or asyncio.get_event_loop()
if config["storage"]["driver"] == "local":
self.fs = fslocal.FsLocal()
self.fs.fs_connect(config["storage"])
+ elif config["storage"]["driver"] == "mongo":
+ self.fs = fsmongo.FsMongo()
+ self.fs.fs_connect(config["storage"])
else:
raise LcmException("Invalid configuration param '{}' at '[storage]':'driver'".format(
config["storage"]["driver"]))
# 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.vim = vim_sdn.VimLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config, self.loop)
- self.wim = vim_sdn.WimLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config, self.loop)
- self.sdn = vim_sdn.SdnLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.ro_config, self.loop)
- self.k8scluster = vim_sdn.K8sClusterLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.vca_config, self.loop)
- self.k8srepo = vim_sdn.K8sRepoLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.vca_config, self.loop)
+ self.ns = ns.NsLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.netslice = netslice.NetsliceLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.vim = vim_sdn.VimLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.wim = vim_sdn.WimLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.sdn = vim_sdn.SdnLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.k8scluster = vim_sdn.K8sClusterLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
+ self.k8srepo = vim_sdn.K8sRepoLcm(self.db, self.msg, self.fs, self.lcm_tasks, self.config, self.loop)
async def check_RO_version(self):
tries = 14
last_error = None
while True:
try:
- ro_server = ROclient.ROClient(self.loop, **self.ro_config)
+ if self.config["ro_config"].get("ng"):
+ ro_server = NgRoClient(self.loop, **self.config["ro_config"])
+ else:
+ ro_server = ROClient(self.loop, **self.config["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:
+ except (ROClientException, NgRoException) as e:
tries -= 1
- error_text = "Error while connecting to RO on {}: {}".format(self.ro_config["endpoint_url"], e)
+ error_text = "Error while connecting to RO on {}: {}".format(self.config["ro_config"]["uri"], e)
if tries <= 0:
self.logger.critical(error_text)
raise LcmException(error_text)
except Exception as e:
self.logger.error("Cannot write into '{}' for healthcheck: {}".format(health_check_file, e))
return
+ elif topic == "pla":
+ if command == "placement":
+ self.ns.update_nsrs_with_pla_result(params)
+ return
elif topic == "k8scluster":
if command == "create" or command == "created":
k8scluster_id = params.get("_id")
self.lcm_tasks.register("k8srepo", k8srepo_id, order_id, "k8srepo_delete", task)
return
elif topic == "ns":
- if command == "instantiate" or command == "instantiated":
+ if command == "instantiate":
# self.logger.debug("Deploying NS {}".format(nsr_id))
nslcmop = params
nslcmop_id = nslcmop["_id"]
task = asyncio.ensure_future(self.ns.instantiate(nsr_id, nslcmop_id))
self.lcm_tasks.register("ns", nsr_id, nslcmop_id, "ns_instantiate", task)
return
- elif command == "terminate" or command == "terminated":
+ elif command == "terminate":
# self.logger.debug("Deleting NS {}".format(nsr_id))
nslcmop = params
nslcmop_id = nslcmop["_id"]
elif command in ("terminated", "instantiated", "scaled", "actioned"): # "scaled-cooldown-time"
return
elif topic == "nsi": # netslice LCM processes (instantiate, terminate, etc)
- if command == "instantiate" or command == "instantiated":
+ if command == "instantiate":
# self.logger.debug("Instantiating Network Slice {}".format(nsilcmop["netsliceInstanceId"]))
nsilcmop = params
nsilcmop_id = nsilcmop["_id"] # slice operation id
task = asyncio.ensure_future(self.netslice.instantiate(nsir_id, nsilcmop_id))
self.lcm_tasks.register("nsi", nsir_id, nsilcmop_id, "nsi_instantiate", task)
return
- elif command == "terminate" or command == "terminated":
+ elif command == "terminate":
# self.logger.debug("Terminating Network Slice NS {}".format(nsilcmop["netsliceInstanceId"]))
nsilcmop = params
nsilcmop_id = nsilcmop["_id"] # slice operation id
return
elif topic == "vim_account":
vim_id = params["_id"]
- if command == "create" or command == "created":
+ 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
print("not implemented show with vim_account")
sys.stdout.flush()
return
- elif command == "edit" or command == "edited":
+ 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" or command == "created":
+ 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
print("not implemented show with wim_account")
sys.stdout.flush()
return
- elif command == "edit" or command == "edited":
+ 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" or command == "created":
+ 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
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" or command == "edited":
+ 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):
self.first_start = True
while self.consecutive_errors < 10:
try:
- topics = ("ns", "vim_account", "wim_account", "sdn", "nsi", "k8scluster", "k8srepo")
+ topics = ("ns", "vim_account", "wim_account", "sdn", "nsi", "k8scluster", "k8srepo", "pla")
topics_admin = ("admin", )
await asyncio.gather(
self.msg.aioread(topics, self.loop, self.kafka_read_callback),
# the configparser library is not suitable, because it does not admit comments at the end of line,
# and not parse integer or boolean
try:
+ # read file as yaml format
with open(config_file) as f:
- conf = yaml.load(f)
+ conf = yaml.load(f, Loader=yaml.Loader)
+ # Ensure all sections are not empty
+ for k in ("global", "timeout", "RO", "VCA", "database", "storage", "message"):
+ if not conf.get(k):
+ conf[k] = {}
+
+ # read all environ that starts with OSMLCM_
for k, v in environ.items():
if not k.startswith("OSMLCM_"):
continue
- k_items = k.lower().split("_")
- if len(k_items) < 3:
+ subject, _, item = k[7:].lower().partition("_")
+ if not item:
continue
- if k_items[1] in ("ro", "vca"):
+ if subject in ("ro", "vca"):
# put in capital letter
- k_items[1] = k_items[1].upper()
- c = conf
+ subject = subject.upper()
try:
- for k_item in k_items[1:-1]:
- c = c[k_item]
- if k_items[-1] == "port":
- c[k_items[-1]] = int(v)
+ if item == "port" or subject == "timeout":
+ conf[subject][item] = int(v)
else:
- c[k_items[-1]] = v
+ conf[subject][item] = v
except Exception as e:
- self.logger.warn("skipping environ '{}' on exception '{}'".format(k, e))
+ self.logger.warning("skipping environ '{}' on exception '{}'".format(k, e))
+
+ # backward compatibility of VCA parameters
+
+ if 'pubkey' in conf["VCA"]:
+ conf["VCA"]['public_key'] = conf["VCA"].pop('pubkey')
+ if 'cacert' in conf["VCA"]:
+ conf["VCA"]['ca_cert'] = conf["VCA"].pop('cacert')
+ if 'apiproxy' in conf["VCA"]:
+ conf["VCA"]['api_proxy'] = conf["VCA"].pop('apiproxy')
+
+ if 'enableosupgrade' in conf["VCA"]:
+ conf["VCA"]['enable_os_upgrade'] = conf["VCA"].pop('enableosupgrade')
+ if isinstance(conf["VCA"].get('enable_os_upgrade'), str):
+ if conf["VCA"]['enable_os_upgrade'].lower() == 'false':
+ conf["VCA"]['enable_os_upgrade'] = False
+ elif conf["VCA"]['enable_os_upgrade'].lower() == 'true':
+ conf["VCA"]['enable_os_upgrade'] = True
+
+ if 'aptmirror' in conf["VCA"]:
+ conf["VCA"]['apt_mirror'] = conf["VCA"].pop('aptmirror')
return conf
except Exception as e:
# --log-socket-port PORT: send logs using this port (default: 9022)")
-def health_check():
- retry = 2
- while retry:
- retry -= 1
- try:
- with open(health_check_file, "r") as f:
- last_received_ping = f.read()
-
- if time() - float(last_received_ping) < Lcm.ping_interval_pace + 10:
- exit(0)
- except Exception:
- pass
- if retry:
- sleep(6)
- exit(1)
-
-
if __name__ == '__main__':
try:
+ # print("SYS.PATH='{}'".format(sys.path))
# load parameters and configuration
# -h
# -c value
elif o in ("-c", "--config"):
config_file = a
elif o == "--health-check":
- health_check()
+ from osm_lcm.lcm_hc import health_check
+ health_check(health_check_file, Lcm.ping_interval_pace)
# elif o == "--log-socket-port":
# log_socket_port = a
# elif o == "--log-socket-host":
projects / osm / LCM.git / blobdiff