0

Get MLAG

Published 20 days ago

MLAG state of the switch: state, negotiation, peer-link, config-sanity, reload-delay (seconds) and the status of every MLAG port (show mlag detail, show mlag config-sanity, show mlag interfaces).

Script arista_eos Verified

The script

Submitted by hugo989 Python3
Verified 4 days ago
1
# py312
2
# requirements:
3
# paramiko==5.1.0
4
# pyeapi==1.0.4
5

6
import base64
7
import hashlib
8
import json
9
import logging
10
import re
11
import socket
12
import ssl
13
import time
14
from typing import TypedDict
15
from urllib.parse import urlsplit
16

17
import paramiko
18
import pyeapi
19

20

21
class arista_eos(TypedDict):
22
    host: str
23
    username: str
24
    password: str
25
    port: int
26
    verify_tls: bool
27
    allow_http: bool
28

29

30
def main(auth: arista_eos, host: str = ""):
31
    """
32
    Get MLAG
33
    MLAG state of the switch: state, negotiation, peer-link, config-sanity, reload-delay (seconds) and the status of every MLAG port (show mlag detail, show mlag config-sanity, show mlag interfaces).
34
    """
35
    auth = with_host(auth, host)
36
    detail, config_sanity, interfaces = node(auth).run_commands(
37
        ["show mlag detail", "show mlag config-sanity", "show mlag interfaces"]
38
    )
39
    return {
40
        **detail,
41
        "config_sanity": config_sanity,
42
        "interfaces": interfaces.get("interfaces"),
43
    }
44

45

46
# One resource can serve every switch that shares a login: the host input, when set, overrides the resource's host.
47
def with_host(auth: arista_eos, host: str):
48
    host = (host or "").strip() or (auth.get("host") or "").strip()
49
    if not host:
50
        raise ValueError("host is required: set it on the resource or pass host")
51
    return {**auth, "host": host}
52

53

54
# SSH transport (transport: ssh): the EOS CLI over an SSH shell, behind the part of pyeapi's Node the scripts use
55
# (run_commands, connection.socket_error, connection.transport.connect), raising pyeapi's own CommandError and
56
# ConnectionError, so the checks and the error mapping are the same for both transports. Show commands in json get
57
# "| json", which prints the eAPI JSON; other commands give { messages: [output] } like eAPI, or {} when silent.
58
# A line starting with "% " is an error, raised as eAPI's CommandError. The host key is checked when the resource
59
# has ssh_host_key (SHA256:... as ssh-keygen -lf prints it).
60
class Ssh:
61
    def __init__(self, auth: arista_eos, timeout: float):
62
        self.auth, self.timeout = auth, timeout
63
        self.connection = self.transport = self
64
        self.socket_error = self.sock = self.chan = None
65

66
    # The TCP connection only, like eAPI's transport.connect(): if it fails, nothing was sent.
67
    def connect(self):
68
        self.sock = socket.create_connection(ssh_addr(self.auth), self.timeout)
69

70
    def lost(self, e):
71
        self.socket_error = e
72
        return pyeapi.eapilib.ConnectionError("ssh", f"SSH connection failed ({e})")
73

74
    def open(self):
75
        auth = self.auth
76
        try:
77
            if not self.sock:
78
                self.connect()
79
            t = paramiko.Transport(self.sock)
80
            t.start_client(timeout=self.timeout)
81
            key = t.get_remote_server_key()
82
        except (OSError, EOFError, paramiko.SSHException) as e:
83
            raise self.lost(e)
84
        fp = "SHA256:" + base64.b64encode(hashlib.sha256(key.asbytes()).digest()).decode().rstrip("=")
85
        if auth.get("ssh_host_key") and auth["ssh_host_key"].strip() != fp:
86
            t.close()
87
            raise RuntimeError(f"{auth['host']}: the SSH host key is {fp}, not the resource's ssh_host_key")
88
        try:
89
            try:
90
                t.auth_password(auth["username"], auth["password"])
91
            except paramiko.BadAuthenticationType:
92
                t.auth_interactive(
93
                    auth["username"], lambda _t, _i, prompts: [auth["password"]] * len(prompts)
94
                )
95
        except paramiko.AuthenticationException as e:
96
            t.close()
97
            raise pyeapi.eapilib.ConnectionError("ssh", str(e))
98
        except (OSError, EOFError, paramiko.SSHException) as e:
99
            raise self.lost(e)
100
        try:
101
            self.chan = t.open_session()
102
            self.chan.get_pty(width=4000)
103
            self.chan.invoke_shell()
104
            self.prompt = None
105
            out = self.read()
106
            self.prompt = re.escape(re.split(r"[(>#]", out.splitlines()[-1].strip())[0])
107
            if out.rstrip().endswith(">"):
108
                self.cli("enable")
109
            self.cli("terminal length 0")
110
            self.cli("terminal width 32767")
111
        except (OSError, EOFError, paramiko.SSHException) as e:
112
            raise self.lost(e)
113

114
    # Reads until the prompt. Questions eAPI never asks are answered as eAPI behaves: confirm, don't save.
115
    def read(self):
116
        buf, end = "", time.monotonic() + self.timeout
117
        prompt = (self.prompt or r"[\w.\-]+") + r"(\([^)\r\n]*\))?[>#] ?$"
118
        while True:
119
            self.chan.settimeout(max(end - time.monotonic(), 0.01))
120
            chunk = self.chan.recv(65536)
121
            if not chunk:
122
                raise self.lost("connection closed")
123
            buf += chunk.decode(errors="replace")
124
            tail = buf[-300:]
125
            if re.search(r"(^|\n)" + prompt, tail):
126
                return buf
127
            for question, answer in (
128
                # enable asks for a password on switches that land the user unprivileged: the login password.
129
                (r"(^|\n)Password:\s*$", self.auth["password"]),
130
                (r"\[confirm\]\s*$", ""),
131
                (r"Save\?.*\[yes/no[^\]]*\]:?\s*$", "no"),
132
                (r"\[(y|yes)/(n|no)\][:?]?\s*$", "y"),
133
            ):
134
                if re.search(question, tail, re.I):
135
                    self.chan.send(answer + "\r")
136
                    buf += "\n"
137

138
    # One command: its output without the echoed command and the prompt; progress lines keep their last state.
139
    def cli(self, cmd):
140
        try:
141
            self.chan.send(cmd + "\r")
142
            out = self.read()
143
        except (OSError, EOFError, paramiko.SSHException) as e:
144
            raise self.lost(e)
145
        self.mode = out.rstrip().splitlines()[-1]
146
        lines = [l.rstrip("\r").split("\r")[-1] for l in out.split("\n")]
147
        return "\n".join(lines[1:-1]).strip("\n")
148

149
    def run_commands(self, cmds, encoding="json", **_):
150
        try:
151
            if not self.chan:
152
                self.open()
153
            if "(config" in self.mode:
154
                self.cli("end")
155
            results = []
156
            for i, c in enumerate(cmds):
157
                # eAPI's { cmd, revision } form is the CLI's "| json revision N".
158
                cmd, rev = (c["cmd"], c.get("revision")) if isinstance(c, dict) else (c, None)
159
                show = encoding == "json" and (rev or re.match(r"\s*sh(ow)?\s", cmd)) and not re.search(r"\|\s*json", cmd)
160
                # pyeapi sends "<cmd> MULTILINE: <text>" (banners) as cmd + input; the CLI reads the text up to EOF.
161
                head, multi, text = cmd.partition("MULTILINE:")
162
                # The shell would run what follows a line break as another command; eAPI refuses it too.
163
                if re.search(r"[\r\n]", head):
164
                    raise ValueError(f"a command may not contain a line break: {head!r}")
165
                line = "\r".join([head.strip(), *text.strip().splitlines(), "EOF"]) if multi else cmd
166
                out = self.cli(f"{cmd} | json{f' revision {rev}' if rev else ''}" if show else line)
167
                errors = [l[2:] for l in out.splitlines() if l.startswith("% ")]
168
                code, kind = 1002, "invalid command"
169
                if show and not errors:
170
                    code, kind = 1000, "could not run command"
171
                    try:
172
                        result = json.loads(out)
173
                    except ValueError:
174
                        errors = [out[:200]]
175
                    else:
176
                        errors = result.get("errors") or []
177
                if errors:
178
                    raise pyeapi.eapilib.CommandError(
179
                        code,
180
                        f"CLI command {i + 2} of {len(cmds) + 1} '{cmd}' failed: {kind}",
181
                        command_error="; ".join(errors),
182
                        commands=cmds,
183
                        output=results,
184
                    )
185
                if encoding != "json":
186
                    result = {"output": out + "\n" if out else ""}
187
                elif not show:
188
                    # The CLI prints eAPI's warnings as "! " notices.
189
                    notices = [l[2:].strip() for l in out.splitlines() if l.startswith("! ")]
190
                    out = "\n".join(l for l in out.splitlines() if not l.startswith("! ")).strip()
191
                    result = {"messages": [out]} if out and not multi else {}
192
                    if notices:
193
                        result["warnings"] = notices
194
                results.append(result)
195
            return results
196
        except pyeapi.eapilib.ConnectionError:
197
            if self.chan:
198
                self.chan.close()
199
            self.sock = self.chan = None
200
            raise
201

202

203
# paramiko logs a traceback when a rebooting switch drops the session.
204
logging.getLogger("paramiko").addHandler(logging.NullHandler())
205

206

207
# host, or host:port ([v6]:port), else port, else 22.
208
def ssh_addr(auth: arista_eos):
209
    h = auth["host"]
210
    if "://" in h:
211
        raise ValueError(f"with transport ssh, host is an address or a hostname (with :port), not a URL: {h}")
212
    url = urlsplit(f"ssh://{h}" if h.count(":") <= 1 or h.startswith("[") else f"ssh://[{h}]")
213
    return url.hostname, url.port or int(auth.get("port") or 22)
214

215

216
# Every action raises DeviceUnreachable when the switch can't be reached and AuthFailure when it refuses the
217
# credential, so a flow can retry on result.error.name. Command errors stay pyeapi's CommandError.
218
def node(auth: arista_eos, timeout: float = 60):
219
    eos = open_node(auth, timeout)
220
    run = eos.run_commands
221

222
    def run_commands(*args, **kwargs):
223
        try:
224
            return run(*args, **kwargs)
225
        except pyeapi.eapilib.ConnectionError as e:
226
            raise connection_error(auth, eos, e)
227

228
    eos.run_commands = run_commands
229
    return eos
230

231

232
# pyeapi 1.0.4 raises ConnectionError for a socket error (kept in socket_error), an answer that isn't JSON (eAPI
233
# still starting, 5xx) and a 401, the only one with neither.
234
def connection_error(auth, eos, e):
235
    # A certificate the resource does not trust is a setting to fix (verify_tls, ca_certificate), not worth a retry.
236
    if isinstance(eos.connection.socket_error, ssl.SSLCertVerificationError):
237
        return RuntimeError(f"{auth['host']}: {eos.connection.socket_error}")
238
    if eos.connection.socket_error is None and e.message != "unable to connect to eAPI":
239
        return AuthFailure(f"{auth['host']}: {'SSH' if auth.get('transport') == 'ssh' else 'eAPI'} refused the credential ({e.message})")
240
    return DeviceUnreachable(f"{auth['host']}: {e.message}")
241

242

243
class DeviceUnreachable(Exception):
244
    pass
245

246

247
class AuthFailure(Exception):
248
    pass
249

250

251
# pyeapi logs a traceback for every socket error.
252
logging.getLogger("pyeapi").addHandler(logging.NullHandler())
253

254

255
# host is an address or a URL (https://10.0.0.11:8443); a bare IPv6 address is bracketed. Only https, or http when the
256
# resource ticks allow_http (Basic auth then crosses the network in cleartext). pyeapi skips certificate checks unless it
257
# is given a context, so one is always passed: verifying, or not when the resource unticks verify_tls (EOS ships a
258
# self-signed cert).
259
def open_node(auth: arista_eos, timeout: float = 60):
260
    if auth.get("transport") == "ssh":
261
        return Ssh(auth, timeout)
262
    host = auth["host"]
263
    if "://" not in host:
264
        host = f"https://[{host}]" if host.count(":") > 1 and "[" not in host else f"https://{host}"
265
    url = urlsplit(host)
266
    if not url.hostname or (url.scheme != "https" and not (url.scheme == "http" and auth.get("allow_http"))):
267
        raise ValueError(f"host must be an address or an https:// URL (http:// needs allow_http on the resource): {auth['host']}")
268
    # ca_certificate: the PEM of a private CA, trusted instead of the system's CAs.
269
    context = ssl.create_default_context(cadata=(auth.get("ca_certificate") or "").strip() or None)
270
    if auth.get("verify_tls") is False:
271
        context.check_hostname = False
272
        context.verify_mode = ssl.CERT_NONE
273
    return pyeapi.connect(
274
        transport=url.scheme,
275
        host=url.hostname,
276
        port=url.port or auth.get("port") or None,
277
        username=auth["username"],
278
        password=auth["password"],
279
        context=context,
280
        timeout=timeout,
281
        return_node=True,
282
    )
283