SetupFramework: log thread error to console
[csit.git] / resources / libraries / python / SetupFramework.py
1 # Copyright (c) 2019 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
13
14 """This module exists to provide setup utilities for the framework on topology
15 nodes. All tasks required to be run before the actual tests are started is
16 supposed to end up here.
17 """
18
19 from os import environ, remove
20 from os.path import basename
21 from tempfile import NamedTemporaryFile
22 import threading
23
24 from robot.api import logger
25
26 from resources.libraries.python.Constants import Constants as con
27 from resources.libraries.python.ssh import exec_cmd_no_error, scp_node
28 from resources.libraries.python.LocalExecution import run
29 from resources.libraries.python.topology import NodeType
30
31 __all__ = ["SetupFramework"]
32
33
34 def pack_framework_dir():
35     """Pack the testing WS into temp file, return its name.
36
37     :returns: Tarball file name.
38     :rtype: str
39     :raises Exception: When failed to pack testing framework.
40     """
41
42     try:
43         directory = environ["TMPDIR"]
44     except KeyError:
45         directory = None
46
47     if directory is not None:
48         tmpfile = NamedTemporaryFile(suffix=".tgz", prefix="csit-testing-",
49                                      dir="{0}".format(directory))
50     else:
51         tmpfile = NamedTemporaryFile(suffix=".tgz", prefix="csit-testing-")
52     file_name = tmpfile.name
53     tmpfile.close()
54
55     run(["tar", "--sparse", "--exclude-vcs", "--exclude=output*.xml",
56          "--exclude=./tmp", "-zcf", file_name, "."],
57         check=True, msg="Could not pack testing framework")
58
59     return file_name
60
61
62 def copy_tarball_to_node(tarball, node):
63     """Copy tarball file from local host to remote node.
64
65     :param tarball: Path to tarball to upload.
66     :param node: Dictionary created from topology.
67     :type tarball: str
68     :type node: dict
69     :returns: nothing
70     """
71     host = node['host']
72     logger.console('Copying tarball to {0} starts.'.format(host))
73     scp_node(node, tarball, "/tmp/")
74     logger.console('Copying tarball to {0} done.'.format(host))
75
76
77 def extract_tarball_at_node(tarball, node):
78     """Extract tarball at given node.
79
80     Extracts tarball using tar on given node to specific CSIT location.
81
82     :param tarball: Path to tarball to upload.
83     :param node: Dictionary created from topology.
84     :type tarball: str
85     :type node: dict
86     :returns: nothing
87     :raises RuntimeError: When failed to unpack tarball.
88     """
89     host = node['host']
90     logger.console('Extracting tarball to {0} on {1} starts.'
91                    .format(con.REMOTE_FW_DIR, host))
92     exec_cmd_no_error(
93         node, "sudo rm -rf {1}; mkdir {1}; tar -zxf {0} -C {1};"
94         " rm -f {0}".format(tarball, con.REMOTE_FW_DIR),
95         message='Failed to extract {0} at node {1}'.format(tarball, host),
96         timeout=30, include_reason=True)
97     logger.console('Extracting tarball to {0} on {1} done.'
98                    .format(con.REMOTE_FW_DIR, host))
99
100
101 def create_env_directory_at_node(node):
102     """Create fresh virtualenv to a directory, install pip requirements.
103
104     :param node: Node to create virtualenv on.
105     :type node: dict
106     :returns: nothing
107     :raises RuntimeError: When failed to setup virtualenv.
108     """
109     host = node['host']
110     logger.console('Virtualenv setup including requirements.txt on {0} starts.'
111                    .format(host))
112     exec_cmd_no_error(
113         node, 'cd {0} && rm -rf env'
114         ' && virtualenv --system-site-packages --never-download env'
115         ' && source env/bin/activate && pip install -r requirements.txt'
116         .format(con.REMOTE_FW_DIR), timeout=100, include_reason=True,
117         message="Failed install at node {host}".format(host=host))
118     logger.console('Virtualenv setup on {0} done.'.format(host))
119
120
121 def setup_node(node, tarball, remote_tarball, results=None):
122     """Copy a tarball to a node and extract it.
123
124     :param node: A node where the tarball will be copied and extracted.
125     :param tarball: Local path of tarball to be copied.
126     :param remote_tarball: Remote path of the tarball.
127     :param results: A list where to store the result of node setup, optional.
128     :type node: dict
129     :type tarball: str
130     :type remote_tarball: str
131     :type results: list
132     :returns: True - success, False - error
133     :rtype: bool
134     """
135     host = node['host']
136     try:
137         copy_tarball_to_node(tarball, node)
138         extract_tarball_at_node(remote_tarball, node)
139         if node['type'] == NodeType.TG:
140             create_env_directory_at_node(node)
141     except RuntimeError as exc:
142         logger.console("Node {node} setup failed, error: {err!r}".format(
143             node=host, err=exc))
144         result = False
145     else:
146         logger.console('Setup of node {0} done.'.format(host))
147         result = True
148
149     if isinstance(results, list):
150         results.append(result)
151     return result
152
153
154 def delete_local_tarball(tarball):
155     """Delete local tarball to prevent disk pollution.
156
157     :param tarball: Path of local tarball to delete.
158     :type tarball: str
159     :returns: nothing
160     """
161     remove(tarball)
162
163
164 def delete_framework_dir(node):
165     """Delete framework directory in /tmp/ on given node.
166
167     :param node: Node to delete framework directory on.
168     :type node: dict
169     """
170     host = node['host']
171     logger.console(
172         'Deleting framework directory on {0} starts.'.format(host))
173     exec_cmd_no_error(
174         node, 'sudo rm -rf {0}'.format(con.REMOTE_FW_DIR),
175         message="Framework delete failed at node {host}".format(host=host),
176         timeout=100, include_reason=True)
177     logger.console(
178         'Deleting framework directory on {0} done.'.format(host))
179
180
181 def cleanup_node(node, results=None):
182     """Delete a tarball from a node.
183
184     :param node: A node where the tarball will be delete.
185     :param results: A list where to store the result of node cleanup, optional.
186     :type node: dict
187     :type results: list
188     :returns: True - success, False - error
189     :rtype: bool
190     """
191     host = node['host']
192     try:
193         delete_framework_dir(node)
194     except RuntimeError:
195         logger.error("Cleanup of node {0} failed.".format(host))
196         result = False
197     else:
198         logger.console('Cleanup of node {0} done.'.format(host))
199         result = True
200
201     if isinstance(results, list):
202         results.append(result)
203     return result
204
205
206 class SetupFramework(object):
207     """Setup suite run on topology nodes.
208
209     Many VAT/CLI based tests need the scripts at remote hosts before executing
210     them. This class packs the whole testing directory and copies it over
211     to all nodes in topology under /tmp/
212     """
213
214     @staticmethod
215     def setup_framework(nodes):
216         """Pack the whole directory and extract in temp on each node.
217
218         :param nodes: Topology nodes.
219         :type nodes: dict
220         :raises RuntimeError: If setup framework failed.
221         """
222
223         tarball = pack_framework_dir()
224         msg = 'Framework packed to {0}'.format(tarball)
225         logger.console(msg)
226         logger.trace(msg)
227         remote_tarball = "/tmp/{0}".format(basename(tarball))
228
229         results = []
230         threads = []
231
232         for node in nodes.values():
233             args = node, tarball, remote_tarball, results
234             thread = threading.Thread(target=setup_node, args=args)
235             thread.start()
236             threads.append(thread)
237
238         logger.info(
239             'Executing node setups in parallel, waiting for threads to end')
240
241         for thread in threads:
242             thread.join()
243
244         logger.info('Results: {0}'.format(results))
245
246         delete_local_tarball(tarball)
247         if all(results):
248             logger.console('All nodes are ready.')
249         else:
250             raise RuntimeError('Failed to setup framework.')
251
252
253 class CleanupFramework(object):
254     """Clean up suite run on topology nodes."""
255
256     @staticmethod
257     def cleanup_framework(nodes):
258         """Perform cleanup on each node.
259
260         :param nodes: Topology nodes.
261         :type nodes: dict
262         :raises RuntimeError: If cleanup framework failed.
263         """
264
265         results = []
266         threads = []
267
268         for node in nodes.values():
269             thread = threading.Thread(target=cleanup_node,
270                                       args=(node, results))
271             thread.start()
272             threads.append(thread)
273
274         logger.info(
275             'Executing node cleanups in parallel, waiting for threads to end.')
276
277         for thread in threads:
278             thread.join()
279
280         logger.info('Results: {0}'.format(results))
281
282         if all(results):
283             logger.console('All nodes cleaned up.')
284         else:
285             raise RuntimeError('Failed to cleaned up framework.')

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.