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         self._logger.info('Killing VNF...')
  55
  56         # force termination of VNF and wait for it to terminate; It will avoid
  57         # sporadic reboot of host. (caused by hugepages or DPDK ports)
  58         super(IVnf, self).kill(signal='-9', sleep=10)
  59
  60     def execute(self, cmd, delay=0):
  61         """
  62         execute ``cmd`` with given ``delay``.
  63
  64         This method makes asynchronous call to guest system
  65         and waits given ``delay`` before returning. Can be
  66         used with ``wait`` method to create synchronous call.
  67
  68         :param cmd: Command to execute on guest system.
  69         :param delay: Delay (in seconds) to wait after sending
  70                       command before returning. Please note that
  71                       this value can be floating point which
  72                       allows to pass milliseconds.
  73
  74         :returns: None.
  75         """
  76         self._logger.debug('%s%s', self._log_prefix, cmd)
  77         self._child.sendline(cmd)
  78         time.sleep(delay)
  79
  80     def wait(self, prompt='', timeout=30):
  81         """
  82         wait for ``prompt`` on guest system for given ``timeout``.
  83
  84         This method ends based on two conditions:
  85         * ``prompt`` has been detected
  86         * ``timeout`` has been reached.
  87
  88         :param prompt: method end condition. If ``prompt``
  89                              won't be detected during given timeout,
  90                              method will return False.
  91         :param timeout: Time to wait for prompt (in seconds).
  92                         Please note that this value can be floating
  93                         point which allows to pass milliseconds.
  94
  95         :returns: True if result_cmd has been detected before
  96                   timeout has been reached, False otherwise.
  97         """
  98         self._child.expect(prompt, timeout=timeout)
  99
 100     def execute_and_wait(self, cmd, timeout=30, prompt=''):
 101         """
 102         execute ``cmd`` with given ``timeout``.
 103
 104         This method makes synchronous call to guest system
 105         and waits till ``cmd`` execution is finished
 106         (based on ``prompt value) or ''timeout'' has
 107         been reached.
 108
 109         :param cmd: Command to execute on guest system.
 110         :param timeout: Timeout till the end of execution is not
 111                         detected.
 112         :param prompt: method end condition. If ``prompt``
 113                              won't be detected during given timeout,
 114                              method will return False. If no argument
 115                              or None value will be passed, default
 116                              ``prompt`` passed in __init__
 117                              method will be used.
 118
 119         :returns: True if end of execution has been detected
 120                   before timeout has been reached, False otherwise.
 121         """
 122         self.execute(cmd)
 123         self.wait(prompt=prompt, timeout=timeout)
 124
 125     def validate_start(self, dummy_result):
 126         """ Validate call of VNF start()
 127         """
 128         if self._child and self._child.isalive():
 129             return True
 130         else:
 131             return False
 132
 133     def validate_stop(self, result):
 134         """ Validate call of fVNF stop()
 135         """
 136         return not self.validate_start(result)
 137
 138     @staticmethod
 139     def reset_vnf_counter():
 140         """
 141         Reset internal VNF counters
 142
 143         This method is static
 144         """
 145         IVnf._number_vnfs = 0
 146