aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python/PapiExecutor.py
blob: 6a47b9497f0d106e6c0db7610cd77b2b4a5d6ac1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
# Copyright (c) 2018 Cisco and/or its affiliates.
# 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.

"""Python API executor library."""

import binascii
import json

from paramiko.ssh_exception import SSHException
from robot.api import logger

from resources.libraries.python.constants import Constants
from resources.libraries.python.PapiErrors import PapiInitError, \
    PapiJsonFileError, PapiCommandError, PapiCommandInputError
# TODO: from resources.libraries.python.PapiHistory import PapiHistory
from resources.libraries.python.ssh import SSH, SSHTimeout

__all__ = ['PapiExecutor']


class PapiExecutor(object):
    """Contains methods for executing Python API commands on DUTs."""

    def __init__(self, node):
        self._stdout = None
        self._stderr = None
        self._ret_code = None
        self._node = node
        self._json_data = None
        self._api_reply = list()
        self._api_data = None

        self._ssh = SSH()
        try:
            self._ssh.connect(node)
        except:
            raise SSHException('Cannot open SSH connection to host {host} to '
                               'execute PAPI command(s)'.
                               format(host=self._node['host']))

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

    @staticmethod
    def _process_api_data(api_d):
        """Process API data for smooth converting to JSON string.

        Apply binascii.hexlify() method for string values.

        :param api_d: List of APIs with their arguments.
        :type api_d: list
        :returns: List of APIs with arguments pre-processed for JSON.
        :rtype: list
        """

        api_data_processed = list()
        for api in api_d:
            api_name = api['api_name']
            api_args = api['api_args']
            api_processed = dict(api_name=api_name)
            api_args_processed = dict()
            for a_k, a_v in api_args.iteritems():
                value = binascii.hexlify(a_v) if isinstance(a_v, str) else a_v
                api_args_processed[str(a_k)] = value
            api_processed['api_args'] = api_args_processed
            api_data_processed.append(api_processed)
        return api_data_processed

    @staticmethod
    def _revert_api_reply(api_r):
        """Process API reply / a part of API reply.

        Apply binascii.unhexlify() method for unicode values.

        :param api_r: API reply.
        :type api_r: dict
        :returns: Processed API reply / a part of API reply.
        :rtype: dict
        """

        reply_dict = dict()
        reply_value = dict()
        for reply_key, reply_v in api_r.iteritems():
            for a_k, a_v in reply_v.iteritems():
                value = binascii.unhexlify(a_v) if isinstance(a_v, unicode) \
                    else a_v
                reply_value[a_k] = value
            reply_dict[reply_key] = reply_value
        return reply_dict

    def _process_reply(self, api_reply):
        """Process API reply.

        :param api_reply: API reply.
        :type api_reply: dict or list of dict
        :returns: Processed API reply.
        :rtype: list or dict
        """

        if isinstance(api_reply, list):
            reverted_reply = list()
            for a_r in api_reply:
                reverted_reply.append(self._revert_api_reply(a_r))
        else:
            reverted_reply = self._revert_api_reply(api_reply)
        return reverted_reply

    def _process_json_data(self):
        """Process received JSON data."""

        for data in self._json_data:
            api_name = data['api_name']
            api_reply = data['api_reply']
            api_reply_processed = dict(
                api_name=api_name, api_reply=self._process_reply(api_reply))
            self._api_reply.append(api_reply_processed)

    def execute_papi(self, api_data, timeout=120):
        """Execute PAPI command(s) on remote node and store the result.

        :param api_data: List of APIs with their arguments.
        :param timeout: Timeout in seconds.
        :type api_data: list
        :type timeout: int
        :raises SSHTimeout: If PAPI command(s) execution is timed out.
        :raises PapiInitError: If PAPI initialization failed.
        :raises PapiJsonFileError: If no api.json file found.
        :raises PapiCommandError: If PAPI command(s) execution failed.
        :raises PapiCommandInputError: If invalid attribute name or invalid
            value is used in API call.
        :raises RuntimeError: If PAPI executor failed due to another reason.
        """
        self._api_data = api_data
        api_data_processed = self._process_api_data(api_data)
        json_data = json.dumps(api_data_processed)

        cmd = "python {fw_dir}/{papi_provider} --json_data '{json}'".format(
            fw_dir=Constants.REMOTE_FW_DIR,
            papi_provider=Constants.RESOURCES_PAPI_PROVIDER,
            json=json_data)

        try:
            ret_code, stdout, stderr = self._ssh.exec_command_sudo(
                cmd=cmd, timeout=timeout)
        except SSHTimeout:
            logger.error('PAPI command(s) execution timeout on host {host}:'
                         '\n{apis}'.format(host=self._node['host'],
                                           apis=self._api_data))
            raise
        except (PapiInitError, PapiJsonFileError, PapiCommandError,
                PapiCommandInputError):
            logger.error('PAPI command(s) execution failed on host {host}'.
                         format(host=self._node['host']))
            raise
        except:
            raise RuntimeError('PAPI command(s) execution on host {host} '
                               'failed: {apis}'.format(host=self._node['host'],
                                                       apis=self._api_data))

        self._ret_code = ret_code
        self._stdout = stdout
        self._stderr = stderr

    def papi_should_have_failed(self):
        """Read return code from last executed script and raise exception if the
        PAPI command(s) didn't fail.

        :raises RuntimeError: When no PAPI command executed.
        :raises AssertionError: If PAPI command(s) execution passed.
        """

        if self._ret_code is None:
            raise RuntimeError("First execute the PAPI command(s)!")
        if self._ret_code == 0:
            raise AssertionError(
                "PAPI command(s) execution passed, but failure was expected: "
                "{apis}".format(apis=self._api_data))

    def papi_should_have_passed(self):
        """Read return code from last executed script and raise exception if the
        PAPI command(s) failed.

        :raises RuntimeError: When no PAPI command executed.
        :raises AssertionError: If PAPI command(s) execution failed.
        """

        if self._ret_code is None:
            raise RuntimeError("First execute the PAPI command(s)!")
        if self._ret_code != 0:
            raise AssertionError(
                "PAPI command(s) execution failed, but success was expected: "
                "{apis}".format(apis=self._api_data))

    def get_papi_stdout(self):
        """Returns value of stdout from last executed PAPI command(s)."""

        return self._stdout

    def get_papi_stderr(self):
        """Returns value of stderr from last executed PAPI command(s)."""

        return self._stderr

    def get_papi_reply(self):
        """Returns api reply from last executed PAPI command(s)."""

        self._json_data = json.loads(self._stdout)
        self._process_json_data()

        return self._api_reply