aboutsummaryrefslogtreecommitdiffstats
path: root/resources/libraries/python/ssh.py
blob: 2de6f4a36e34e0e56dc291c8029a1142d1d463b2 (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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
# Copyright (c) 2016 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.
import paramiko
from paramiko import RSAKey
import StringIO
from scp import SCPClient
from time import time
from robot.api import logger
from interruptingcow import timeout
from robot.utils.asserts import assert_equal, assert_not_equal
from socket import timeout as socket_timeout

__all__ = ["exec_cmd", "exec_cmd_no_error"]

# TODO: load priv key


class SSH(object):

    __MAX_RECV_BUF = 10*1024*1024
    __existing_connections = {}

    def __init__(self):
        pass

    def _node_hash(self, node):
        return hash(frozenset([node['host'], node['port']]))

    def connect(self, node):
        """Connect to node prior to running exec_command or scp.

        If there already is a connection to the node, this method reuses it.
        """
        node_hash = self._node_hash(node)
        if node_hash in SSH.__existing_connections:
            self._ssh = SSH.__existing_connections[node_hash]
            logger.debug('reusing ssh: {0}'.format(self._ssh))
        else:
            start = time()
            pkey = None
            if 'priv_key' in node:
                pkey = RSAKey.from_private_key(
                        StringIO.StringIO(node['priv_key']))

            self._ssh = paramiko.SSHClient()
            self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

            self._ssh.connect(node['host'], username=node['username'],
                              password=node.get('password'), pkey=pkey)

            SSH.__existing_connections[node_hash] = self._ssh

            logger.trace('connect took {} seconds'.format(time() - start))
            logger.debug('new ssh: {0}'.format(self._ssh))

        logger.debug('Connect peer: {0}'.
                format(self._ssh.get_transport().getpeername()))
        logger.debug('Connections: {0}'.format(str(SSH.__existing_connections)))

    def exec_command(self, cmd, timeout=10):
        """Execute SSH command on a new channel on the connected Node.

        Returns (return_code, stdout, stderr).
        """
        logger.trace('exec_command on {0}: {1}'
                     .format(self._ssh.get_transport().getpeername(), cmd))
        start = time()
        chan = self._ssh.get_transport().open_session()
        if timeout is not None:
            chan.settimeout(int(timeout))
        chan.exec_command(cmd)
        end = time()
        logger.trace('exec_command on {0} took {1} seconds'.format(
            self._ssh.get_transport().getpeername(), end-start))

        stdout = ""
        while True:
            try:
                buf = chan.recv(self.__MAX_RECV_BUF)
                stdout += buf
                if not buf:
                    break
            except socket_timeout:
                logger.trace('Channels stdout timeout occurred')
                break

        stderr = ""
        while True:
            try:
                buf = chan.recv_stderr(self.__MAX_RECV_BUF)
                stderr += buf
                if not buf:
                    break
            except socket_timeout:
                logger.trace('Channels stderr timeout occurred')
                break

        return_code = chan.recv_exit_status()
        logger.trace('chan_recv/_stderr took {} seconds'.format(time()-end))

        logger.trace('return RC {}'.format(return_code))
        logger.trace('return STDOUT {}'.format(stdout))
        logger.trace('return STDERR {}'.format(stderr))
        return return_code, stdout, stderr

    def exec_command_sudo(self, cmd, cmd_input=None, timeout=10):
        """Execute SSH command with sudo on a new channel on the connected Node.

           :param cmd: Command to be executed.
           :param cmd_input: Input redirected to the command.
           :param timeout: Timeout.
           :return: return_code, stdout, stderr

           :Example:

            >>> from ssh import SSH
            >>> ssh = SSH()
            >>> ssh.connect(node)
            >>> #Execute command without input (sudo -S cmd)
            >>> ssh.exec_command_sudo("ifconfig eth0 down")
            >>> #Execute command with input (sudo -S cmd <<< "input")
            >>> ssh.exec_command_sudo("vpp_api_test", "dump_interface_table")
        """
        if cmd_input is None:
            command = 'sudo -S {c}'.format(c=cmd)
        else:
            command = 'sudo -S {c} <<< "{i}"'.format(c=cmd, i=cmd_input)
        return self.exec_command(command, timeout)

    def interactive_terminal_open(self, time_out=10):
        """Open interactive terminal on a new channel on the connected Node.

           :param time_out: Timeout in seconds.
           :return: SSH channel with opened terminal.

           .. warning:: Interruptingcow is used here, and it uses
               signal(SIGALRM) to let the operating system interrupt program
               execution. This has the following limitations: Python signal
               handlers only apply to the main thread, so you cannot use this
               from other threads. You must not use this in a program that
               uses SIGALRM itself (this includes certain profilers)
        """
        chan = self._ssh.get_transport().open_session()
        chan.get_pty()
        chan.invoke_shell()
        chan.settimeout(int(time_out))

        buf = ''
        try:
            with timeout(time_out, exception=RuntimeError):
                while not buf.endswith(':~$ '):
                    if chan.recv_ready():
                        buf = chan.recv(4096)
        except RuntimeError:
            raise Exception('Open interactive terminal timeout.')
        return chan

    def interactive_terminal_exec_command(self, chan, cmd, prompt,
                                          time_out=10):
        """Execute command on interactive terminal.

           interactive_terminal_open() method has to be called first!

           :param chan: SSH channel with opened terminal.
           :param cmd: Command to be executed.
           :param prompt: Command prompt, sequence of characters used to
               indicate readiness to accept commands.
           :param time_out: Timeout in seconds.
           :return: Command output.

           .. warning:: Interruptingcow is used here, and it uses
               signal(SIGALRM) to let the operating system interrupt program
               execution. This has the following limitations: Python signal
               handlers only apply to the main thread, so you cannot use this
               from other threads. You must not use this in a program that
               uses SIGALRM itself (this includes certain profilers)
        """
        chan.sendall('{c}\n'.format(c=cmd))
        buf = ''
        try:
            with timeout(time_out, exception=RuntimeError):
                while not buf.endswith(prompt):
                    if chan.recv_ready():
                        buf += chan.recv(4096)
        except RuntimeError:
            raise Exception("Exec '{c}' timeout.".format(c=cmd))
        tmp = buf.replace(cmd.replace('\n', ''), '')
        return tmp.replace(prompt, '')

    def interactive_terminal_close(self, chan):
        """Close interactive terminal SSH channel.

           :param: chan: SSH channel to be closed.
        """
        chan.close()

    def scp(self, local_path, remote_path):
        """Copy files from local_path to remote_path.

        connect() method has to be called first!
        """
        logger.trace('SCP {0} to {1}:{2}'.format(
            local_path, self._ssh.get_transport().getpeername(), remote_path))
        # SCPCLient takes a paramiko transport as its only argument
        scp = SCPClient(self._ssh.get_transport())
        start = time()
        scp.put(local_path, remote_path)
        scp.close()
        end = time()
        logger.trace('SCP took {0} seconds'.format(end-start))


def exec_cmd(node, cmd, timeout=None, sudo=False):
    """Convenience function to ssh/exec/return rc, out & err.

    Returns (rc, stdout, stderr).
    """
    if node is None:
        raise TypeError('Node parameter is None')
    if cmd is None:
        raise TypeError('Command parameter is None')
    if len(cmd) == 0:
        raise ValueError('Empty command parameter')

    ssh = SSH()
    try:
        ssh.connect(node)
    except Exception, e:
        logger.error("Failed to connect to node" + e)
        return None

    try:
        if not sudo:
            (ret_code, stdout, stderr) = ssh.exec_command(cmd, timeout=timeout)
        else:
            (ret_code, stdout, stderr) = ssh.exec_command_sudo(cmd,
                                                               timeout=timeout)
    except Exception, e:
        logger.error(e)
        return None

    return (ret_code, stdout, stderr)

def exec_cmd_no_error(node, cmd, timeout=None, sudo=False):
    """Convenience function to ssh/exec/return out & err.
    Verifies that return code is zero.

    Returns (stdout, stderr).
    """
    (rc, stdout, stderr) = exec_cmd(node, cmd, timeout=timeout, sudo=sudo)
    assert_equal(rc, 0, 'Command execution failed: "{}"\n{}'.
                 format(cmd, stderr))
    return (stdout, stderr)