0

Set Boot Image

Published today

Point boot-config at an image on flash (boot system), for the next reload; does not reload. image is flash:/NAME or NAME. Refuses an image that is not on flash. Returns { previous_image, boot_image, warnings }. Upgrade: after Copy Image, before Reload; rollback: pass the previous_image it returned, then Reload.

Script arista_eos Verified

The script

Submitted by hugo989 Python3
Verified 1 day 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, image: str, host: str = ""):
31
    """
32
    Set Boot Image
33
    Point boot-config at an image on flash (boot system), for the next reload; does not reload. image is flash:/NAME or NAME. Refuses an image that is not on flash. Returns { previous_image, boot_image, warnings }. Upgrade: after Copy Image, before Reload; rollback: pass the previous_image it returned, then Reload.
34
    """
35
    auth = with_host(auth, host)
36
    name = flash_name(image)
37
    if name not in flash_dir(auth)["entries"]:
38
        raise ValueError(f"{name} is not on flash")
39
    before, _, set_, _, after = node(auth).run_commands(
40
        ["show boot-config", "configure", f"boot system flash:{name}", "end", "show boot-config"]
41
    )
42
    if after.get("softwareImage") != f"flash:/{name}":
43
        raise RuntimeError(f"boot-config still points to {after.get('softwareImage')}")
44
    return {
45
        "previous_image": before.get("softwareImage") or "",
46
        "boot_image": after["softwareImage"],
47
        "warnings": set_.get("warnings") or [],
48
    }
49

50

51
# A file at the root of flash: "flash:/NAME", "flash:NAME" or "NAME", with only A-Z a-z 0-9 _ . + - in NAME (the name
52
# goes into a CLI command). Returns NAME.
53
def flash_name(path: str):
54
    name = re.sub(r"^flash:/?", "", (path or "").strip())
55
    if not re.fullmatch(r"[\w.+-]+", name) or name in (".", ".."):
56
        raise ValueError(f"expected a file at the root of flash (flash:/NAME, NAME of A-Z a-z 0-9 _ . + -): got {path!r}")
57
    return name
58

59

60
def flash_dir(auth):
61
    [d] = node(auth).run_commands([{"cmd": "dir flash:/", "revision": 2}])
62
    return d["urls"]["flash:/"]
63

64

65
# One resource can serve every switch that shares a login: the host input, when set, overrides the resource's host.
66
def with_host(auth: arista_eos, host: str):
67
    host = (host or "").strip() or (auth.get("host") or "").strip()
68
    if not host:
69
        raise ValueError("host is required: set it on the resource or pass host")
70
    return {**auth, "host": host}
71

72

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

85
    # The TCP connection only, like eAPI's transport.connect(): if it fails, nothing was sent.
86
    def connect(self):
87
        self.sock = socket.create_connection(ssh_addr(self.auth), self.timeout)
88

89
    def lost(self, e):
90
        self.socket_error = e
91
        return pyeapi.eapilib.ConnectionError("ssh", f"SSH connection failed ({e})")
92

93
    def open(self):
94
        auth = self.auth
95
        try:
96
            if not self.sock:
97
                self.connect()
98
            t = paramiko.Transport(self.sock)
99
            t.start_client(timeout=self.timeout)
100
            key = t.get_remote_server_key()
101
        except (OSError, EOFError, paramiko.SSHException) as e:
102
            raise self.lost(e)
103
        fp = "SHA256:" + base64.b64encode(hashlib.sha256(key.asbytes()).digest()).decode().rstrip("=")
104
        if auth.get("ssh_host_key") and auth["ssh_host_key"].strip() != fp:
105
            t.close()
106
            raise RuntimeError(f"{auth['host']}: the SSH host key is {fp}, not the resource's ssh_host_key")
107
        try:
108
            try:
109
                t.auth_password(auth["username"], auth["password"])
110
            except paramiko.BadAuthenticationType:
111
                t.auth_interactive(
112
                    auth["username"], lambda _t, _i, prompts: [auth["password"]] * len(prompts)
113
                )
114
        except paramiko.AuthenticationException as e:
115
            t.close()
116
            raise pyeapi.eapilib.ConnectionError("ssh", str(e))
117
        except (OSError, EOFError, paramiko.SSHException) as e:
118
            raise self.lost(e)
119
        try:
120
            self.chan = t.open_session()
121
            self.chan.get_pty(width=4000)
122
            self.chan.invoke_shell()
123
            self.prompt = None
124
            out = self.read()
125
            self.prompt = re.escape(re.split(r"[(>#]", out.splitlines()[-1].strip())[0])
126
            if out.rstrip().endswith(">"):
127
                self.cli("enable")
128
            self.cli("terminal length 0")
129
            self.cli("terminal width 32767")
130
        except (OSError, EOFError, paramiko.SSHException) as e:
131
            raise self.lost(e)
132

133
    # Reads until the prompt. Questions eAPI never asks are answered as eAPI behaves: confirm, don't save.
134
    def read(self):
135
        buf, end = "", time.monotonic() + self.timeout
136
        prompt = (self.prompt or r"[\w.\-]+") + r"(\([^)\r\n]*\))?[>#] ?$"
137
        while True:
138
            self.chan.settimeout(max(end - time.monotonic(), 0.01))
139
            chunk = self.chan.recv(65536)
140
            if not chunk:
141
                raise self.lost("connection closed")
142
            buf += chunk.decode(errors="replace")
143
            tail = buf[-300:]
144
            if re.search(r"(^|\n)" + prompt, tail):
145
                return buf
146
            for question, answer in (
147
                # enable asks for a password on switches that land the user unprivileged: the login password.
148
                (r"(^|\n)Password:\s*$", self.auth["password"]),
149
                (r"\[confirm\]\s*$", ""),
150
                (r"Save\?.*\[yes/no[^\]]*\]:?\s*$", "no"),
151
                (r"\[(y|yes)/(n|no)\][:?]?\s*$", "y"),
152
            ):
153
                if re.search(question, tail, re.I):
154
                    self.chan.send(answer + "\r")
155
                    buf += "\n"
156

157
    # One command: its output without the echoed command and the prompt; progress lines keep their last state.
158
    def cli(self, cmd):
159
        try:
160
            self.chan.send(cmd + "\r")
161
            out = self.read()
162
        except (OSError, EOFError, paramiko.SSHException) as e:
163
            raise self.lost(e)
164
        self.mode = out.rstrip().splitlines()[-1]
165
        lines = [l.rstrip("\r").split("\r")[-1] for l in out.split("\n")]
166
        return "\n".join(lines[1:-1]).strip("\n")
167

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

221

222
# paramiko logs a traceback when a rebooting switch drops the session.
223
logging.getLogger("paramiko").addHandler(logging.NullHandler())
224

225

226
# host, or host:port ([v6]:port), else port, else 22.
227
def ssh_addr(auth: arista_eos):
228
    h = auth["host"]
229
    if "://" in h:
230
        raise ValueError(f"with transport ssh, host is an address or a hostname (with :port), not a URL: {h}")
231
    url = urlsplit(f"ssh://{h}" if h.count(":") <= 1 or h.startswith("[") else f"ssh://[{h}]")
232
    return url.hostname, url.port or int(auth.get("port") or 22)
233

234

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

241
    def run_commands(*args, **kwargs):
242
        try:
243
            return run(*args, **kwargs)
244
        except pyeapi.eapilib.ConnectionError as e:
245
            raise connection_error(auth, eos, e)
246

247
    eos.run_commands = run_commands
248
    return eos
249

250

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

261

262
class DeviceUnreachable(Exception):
263
    pass
264

265

266
class AuthFailure(Exception):
267
    pass
268

269

270
# pyeapi logs a traceback for every socket error.
271
logging.getLogger("pyeapi").addHandler(logging.NullHandler())
272

273

274
# 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
275
# resource ticks allow_http (Basic auth then crosses the network in cleartext). pyeapi skips certificate checks unless it
276
# is given a context, so one is always passed: verifying, or not when the resource unticks verify_tls (EOS ships a
277
# self-signed cert).
278
def open_node(auth: arista_eos, timeout: float = 60):
279
    if auth.get("transport") == "ssh":
280
        return Ssh(auth, timeout)
281
    host = auth["host"]
282
    if "://" not in host:
283
        host = f"https://[{host}]" if host.count(":") > 1 and "[" not in host else f"https://{host}"
284
    url = urlsplit(host)
285
    if not url.hostname or (url.scheme != "https" and not (url.scheme == "http" and auth.get("allow_http"))):
286
        raise ValueError(f"host must be an address or an https:// URL (http:// needs allow_http on the resource): {auth['host']}")
287
    # ca_certificate: the PEM of a private CA, trusted instead of the system's CAs.
288
    context = ssl.create_default_context(cadata=(auth.get("ca_certificate") or "").strip() or None)
289
    if auth.get("verify_tls") is False:
290
        context.check_hostname = False
291
        context.verify_mode = ssl.CERT_NONE
292
    return pyeapi.connect(
293
        transport=url.scheme,
294
        host=url.hostname,
295
        port=url.port or auth.get("port") or None,
296
        username=auth["username"],
297
        password=auth["password"],
298
        context=context,
299
        timeout=timeout,
300
        return_node=True,
301
    )
302