common/python/rift/mano/sdn/operdata.py

#
#   Copyright 2017 RIFT.IO Inc
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
#

import asyncio
import gi

import rift.tasklets

from gi.repository import(
        RwSdnYang,
        RwsdnalYang,
        RwDts as rwdts,
        RwTypes,
        )
gi.require_version('RwKeyspec', '1.0')
from gi.repository.RwKeyspec import quoted_key


class SDNAccountNotFound(Exception):
    pass


class SDNAccountDtsOperdataHandler(object):
    def __init__(self, dts, log, loop, project):
        self._dts = dts
        self._log = log
        self._loop = loop
        self._project = project

        self.sdn_accounts = {}
        self._oper = None
        self._rpc = None

    def add_sdn_account(self, account):
        self.sdn_accounts[account.name] = account
        account.start_validate_credentials(self._loop)

    def delete_sdn_account(self, account_name):
        del self.sdn_accounts[account_name]

    def get_saved_sdn_accounts(self, sdn_account_name):
        ''' Get SDN Account corresponding to passed name, or all saved accounts if name is None'''
        saved_sdn_accounts = []

        if sdn_account_name is None or sdn_account_name == "":
            sdn_accounts = list(self.sdn_accounts.values())
            saved_sdn_accounts.extend(sdn_accounts)
        elif sdn_account_name in self.sdn_accounts:
            account = self.sdn_accounts[sdn_account_name]
            saved_sdn_accounts.append(account)
        else:
            errstr = "SDN account {} does not exist".format(sdn_account_name)
            raise KeyError(errstr)

        return saved_sdn_accounts

    @asyncio.coroutine
    def create_notification(self, account):
        xpath = "N,/rw-sdn:sdn-notif"
        ac_status = RwSdnYang.YangNotif_RwSdn_SdnNotif()
        ac_status.name = account.name
        ac_status.message = account.connection_status.details

        yield from self._dts.query_create(xpath, rwdts.XactFlag.ADVISE, ac_status)
        self._log.info("Notification called by creating dts query: %s", ac_status)


    @asyncio.coroutine
    def _register_show_status(self):
        self._log.debug("Registering for show for project {}".format(self._project))
        def get_xpath(sdn_name=None):
            return self._project.add_project("D,/rw-sdn:sdn/rw-sdn:account{}/rw-sdn:connection-status".
                                             format(
                                                 "[rw-sdn:name=%s]" % quoted_key(sdn_name)
                                                 if sdn_name is not None else ''))

        @asyncio.coroutine
        def on_prepare(xact_info, action, ks_path, msg):
            xpath = ks_path.to_xpath(RwSdnYang.get_schema())
            self._log.debug("Got show SDN connection status request: %s", xpath)
            path_entry = RwSdnYang.YangData_RwProject_Project_Sdn_Account.schema().keyspec_to_entry(ks_path)
            sdn_account_name = path_entry.key00.name

            try:
                saved_accounts = self.get_saved_sdn_accounts(sdn_account_name)
                for account in saved_accounts:
                    connection_status = account.connection_status
                    self._log.debug("Responding to SDN connection status request: %s",
                                    connection_status)
                    xact_info.respond_xpath(
                            rwdts.XactRspCode.MORE,
                            xpath=get_xpath(account.name),
                            msg=account.connection_status,
                            )
            except KeyError as e:
                self._log.warning(str(e))
                xact_info.respond_xpath(rwdts.XactRspCode.NA)
                return

            xact_info.respond_xpath(rwdts.XactRspCode.ACK)

        self._oper = yield from self._dts.register(
                xpath=get_xpath(),
                handler=rift.tasklets.DTS.RegistrationHandler(
                    on_prepare=on_prepare),
                flags=rwdts.Flag.PUBLISHER,
                )

    @asyncio.coroutine
    def _register_validate_rpc(self):
        self._log.debug("Registering for rpc for project {}".format(self._project))
        def get_xpath():
            return "/rw-sdn:update-sdn-status"

        @asyncio.coroutine
        def on_prepare(xact_info, action, ks_path, msg):
            if self._project and not self._project.rpc_check(msg, xact_info=xact_info):
                return

            self._log.debug("Got update SDN connection status request: %s", msg)

            if not msg.has_field("sdn_account"):
                raise SDNAccountNotFound("SDN account name not provided")

            sdn_account_name = msg.sdn_account
            try:
                account = self.sdn_accounts[sdn_account_name]
            except KeyError:
                errmsg = "SDN account name %s not found" % sdn_account_name
                self._log.error(errmsg)
                xpath = ks_path.to_xpath(RwSdnYang.get_schema())
                xact_info.send_error_xpath(RwTypes.RwStatus.FAILURE,
                                           xpath,
                                           errmsg)
                xact_info.respond_xpath(rwdts.XactRspCode.NACK)
                return

            account.start_validate_credentials(self._loop)

            yield from self.create_notification(account)

            xact_info.respond_xpath(rwdts.XactRspCode.ACK)

        self._rpc = yield from self._dts.register(
            xpath=get_xpath(),
            handler=rift.tasklets.DTS.RegistrationHandler(
                on_prepare=on_prepare
            ),
            flags=rwdts.Flag.PUBLISHER,
        )

    @asyncio.coroutine
    def register(self):
        yield from self._register_show_status()
        yield from self._register_validate_rpc()

    def deregister(self):
        if self._oper:
            self._oper.deregister()
            self._oper = None

        if self._rpc:
            self._rpc.deregister()
            self._rpc = None