vnfs/vnf/vnf.py

   1 # Copyright 2015 Intel Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #   http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 """
  16 Interface for VNF.
  17 """
  18
  19 import time
  20 from tools import tasks
  21
  22 class IVnf(tasks.Process):
  23
  24     """
  25     Interface for VNF.
  26     """
  27
  28     _number_vnfs = 0
  29
  30     def __init__(self):
  31         """
  32         Initialization method.
  33
  34         Purpose of this method is to initialize all
  35         common Vnf data, no services should be started by
  36         this call (use ``start`` method instead).
  37         """
  38         self._number = IVnf._number_vnfs
  39         IVnf._number_vnfs = IVnf._number_vnfs + 1
  40         self._log_prefix = 'vnf_%d_cmd : ' % self._number
  41
  42     def start(self):
  43         """
  44         Starts VNF instance.
  45
  46         This is a blocking function
  47         """
  48         super(IVnf, self).start()
  49
  50     def stop(self):
  51         """
  52         Stops VNF instance.
  53         """
  54         if self.is_running():
  55             self._logger.info('Killing VNF...')
  56
  57             # force termination of VNF and wait for it to terminate; It will avoid
  58             # sporadic reboot of host. (caused by hugepages or DPDK ports)
  59             super(IVnf, self).kill(signal='-9', sleep=10)
  60
  61     def execute(self, cmd, delay=0):
  62         """
  63         execute ``cmd`` with given ``delay``.
  64
  65         This method makes asynchronous call to guest system
  66         and waits given ``delay`` before returning. Can be
  67         used with ``wait`` method to create synchronous call.
  68
  69         :param cmd: Command to execute on guest system.
  70         :param delay: Delay (in seconds) to wait after sending
  71                       command before returning. Please note that
  72                       this value can be floating point which
  73                       allows to pass milliseconds.
  74
  75         :returns: None.
  76         """
  77         self._logger.debug('%s%s', self._log_prefix, cmd)
  78         self._child.sendline(cmd)
  79         time.sleep(delay)
  80
  81     def wait(self, prompt='', timeout=30):
  82         """
  83         wait for ``prompt`` on guest system for given ``timeout``.
  84
  85         This method ends based on two conditions:
  86         * ``prompt`` has been detected
  87         * ``timeout`` has been reached.
  88
  89         :param prompt: method end condition. If ``prompt``
  90                              won't be detected during given timeout,
  91                              method will return False.
  92         :param timeout: Time to wait for prompt (in seconds).
  93                         Please note that this value can be floating
  94                         point which allows to pass milliseconds.
  95
  96         :returns: True if result_cmd has been detected before
  97                   timeout has been reached, False otherwise.
  98         """
  99         self._child.expect(prompt, timeout=timeout)
 100
 101     def execute_and_wait(self, cmd, timeout=30, prompt=''):
 102         """
 103         execute ``cmd`` with given ``timeout``.
 104
 105         This method makes synchronous call to guest system
 106         and waits till ``cmd`` execution is finished
 107         (based on ``prompt value) or ''timeout'' has
 108         been reached.
 109
 110         :param cmd: Command to execute on guest system.
 111         :param timeout: Timeout till the end of execution is not
 112                         detected.
 113         :param prompt: method end condition. If ``prompt``
 114                              won't be detected during given timeout,
 115                              method will return False. If no argument
 116                              or None value will be passed, default
 117                              ``prompt`` passed in __init__
 118                              method will be used.
 119
 120         :returns: True if end of execution has been detected
 121                   before timeout has been reached, False otherwise.
 122         """
 123         self.execute(cmd)
 124         self.wait(prompt=prompt, timeout=timeout)
 125
 126     def validate_start(self, dummy_result):
 127         """ Validate call of VNF start()
 128         """
 129         if self._child and self._child.isalive():
 130             return True
 131         else:
 132             return False
 133
 134     def validate_stop(self, result):
 135         """ Validate call of fVNF stop()
 136         """
 137         return not self.validate_start(result)
 138
 139     @staticmethod
 140     def reset_vnf_counter():
 141         """
 142         Reset internal VNF counters
 143
 144         This method is static
 145         """
 146         IVnf._number_vnfs = 0
 147