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