targetcli 3.0.0__py3-none-any.whl

targetcli/__init__.py

@@ -0,0 +1,21 @@
+'''
+This file is part of targetcli.
+Copyright (c) 2011-2013 by Datera, Inc
+
+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 importlib.metadata
+
+__version__ = importlib.metadata.version('targetcli')

targetcli/targetcli_shell.py

@@ -0,0 +1,326 @@
+'''
+Starts the targetcli CLI shell.
+
+This file is part of targetcli.
+Copyright (c) 2011-2013 by Datera, Inc
+
+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 contextlib
+import fcntl
+import readline
+import socket
+import struct
+import sys
+from os import getenv, getuid
+
+from configshell_fb import ConfigShell, ExecutionError
+from rtslib_fb import RTSLibError
+
+from targetcli import __version__ as targetcli_version
+from targetcli.ui_root import UIRoot
+
+err = sys.stderr
+# lockfile for serializing multiple targetcli requests
+lock_file = '/var/run/targetcli.lock'
+socket_path = '/var/run/targetclid.sock'
+hints = ['/', 'backstores/', 'iscsi/', 'loopback/', 'vhost/', 'xen-pvscsi/',
+         'cd', 'pwd', 'ls', 'set', 'get', 'help', 'refresh', 'status',
+         'clearconfig', 'restoreconfig', 'saveconfig', 'exit']
+
+class TargetCLI(ConfigShell):
+    default_prefs = {'color_path': 'magenta',
+                     'color_command': 'cyan',
+                     'color_parameter': 'magenta',
+                     'color_keyword': 'cyan',
+                     'completions_in_columns': True,
+                     'logfile': None,
+                     'loglevel_console': 'info',
+                     'loglevel_file': 'debug9',
+                     'color_mode': True,
+                     'prompt_length': 30,
+                     'tree_max_depth': 0,
+                     'tree_status_mode': True,
+                     'tree_round_nodes': True,
+                     'tree_show_root': True,
+                     'export_backstore_name_as_model': True,
+                     'auto_enable_tpgt': True,
+                     'auto_add_mapped_luns': True,
+                     'auto_cd_after_create': False,
+                     'auto_save_on_exit': True,
+                     'max_backup_files': '10',
+                     'auto_add_default_portal': True,
+                     'auto_use_daemon': False,
+                     'daemon_use_batch_mode': False,
+                    }
+
+def usage():
+    print(f"Usage: {sys.argv[0]} [--version|--help|CMD|--disable-daemon]", file=err)
+    print("  --version\t\tPrint version", file=err)
+    print("  --help\t\tPrint this information", file=err)
+    print("  CMD\t\t\tRun targetcli shell command and exit", file=err)
+    print("  <nothing>\t\tEnter configuration shell", file=err)
+    print("  --disable-daemon\tTurn-off the global auto use daemon flag", file=err)
+    print("See man page for more information.", file=err)
+    sys.exit(-1)
+
+def version():
+    print(f"{sys.argv[0]} version {targetcli_version}", file=err)
+    sys.exit(0)
+
+def usage_version(cmd):
+    if cmd in {"help", "--help", "-h"}:
+        usage()
+
+    if cmd in {"version", "--version", "-v"}:
+        version()
+
+def try_op_lock(shell, lkfd):
+    '''
+    acquire a blocking lock on lockfile, to serialize multiple requests
+    '''
+    try:
+        fcntl.flock(lkfd, fcntl.LOCK_EX)  # wait here until ongoing request is finished
+    except Exception as e:
+        shell.con.display(
+            shell.con.render_text(
+                f"taking lock on lockfile failed: {e!s}",
+                'red'))
+        sys.exit(1)
+
+def release_op_lock(shell, lkfd):
+    '''
+    release blocking lock on lockfile, which can allow other requests process
+    '''
+    try:
+        fcntl.flock(lkfd, fcntl.LOCK_UN)  # allow other requests now
+    except Exception as e:
+        shell.con.display(
+            shell.con.render_text(
+                f"unlock on lockfile failed: {e!s}",
+                'red'))
+        sys.exit(1)
+    lkfd.close()
+
+def completer(text, state):
+    options = [x for x in hints if x.startswith(text)]
+    try:
+        return options[state]
+    except IndexError:
+        return None
+
+def call_daemon(shell, req, interactive):
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    except OSError as err:
+        shell.con.display(shell.con.render_text(err, 'red'))
+        sys.exit(1)
+
+    try:
+        sock.connect(socket_path)
+    except OSError as err:
+        shell.con.display(shell.con.render_text(err, 'red'))
+        shell.con.display(
+            shell.con.render_text("Currently auto_use_daemon is true, "
+                "hence please make sure targetclid daemon is running ...\n"
+                "(or)\nIncase if you wish to turn auto_use_daemon to false "
+                "then run '#targetcli --disable-daemon'", 'red'))
+        sys.exit(1)
+
+    # Two cases where we want to get pwd:
+    # 1. Before starting shell in interactive mode, needed for setting terminal
+    # 2. And only in Interactive mode, having command 'cd'
+    get_pwd = False
+    if interactive:
+        if not req:
+            req = "pwd"
+            get_pwd = True
+        elif "cd " in req:
+            req += "%pwd"
+            get_pwd = True
+    else:
+        req = "cd /%" + req  # Non-interactive modes always consider start at '/'
+
+    try:
+        # send request
+        sock.sendall(req.encode())
+    except OSError as err:
+        shell.con.display(shell.con.render_text(err, 'red'))
+        sys.exit(1)
+
+    var = sock.recv(4)  # get length of data
+    sending = struct.unpack('i', var)
+    amount_expected = sending[0]
+    amount_received = 0
+
+    # get the actual data in chunks
+    output = ""
+    path = ""
+    while amount_received < amount_expected:
+        data = sock.recv(1024)
+        data = data.decode()
+        amount_received += len(data)
+        output += data
+
+    if get_pwd:
+        output_split = output.splitlines()
+        lines = len(output_split)
+        for i in range(lines):
+            if i == lines - 1:
+                path = str(output_split[i])
+            else:
+                print(str(output_split[i]), end="\n")
+    else:
+        print(output, end="")
+
+    sock.send(b'-END@OF@DATA-')
+    sock.close()
+
+    return path
+
+def switch_to_daemon(shell, interactive):
+    readline.set_completer(completer)
+    readline.set_completer_delims('')
+
+    if 'libedit' in readline.__doc__:
+        readline.parse_and_bind("bind ^I rl_complete")
+    else:
+        readline.parse_and_bind("tab: complete")
+
+    if len(sys.argv) > 1:
+        command = " ".join(sys.argv[1:])
+        call_daemon(shell, command, False)
+        sys.exit(0)
+
+    if interactive:
+        shell.con.display(f"targetcli shell version {targetcli_version}\n"
+                          "Entering targetcli interactive mode for daemonized approach.\n"
+                          "Type 'exit' to quit.\n")
+    else:
+        shell.con.display(f"targetcli shell version {targetcli_version}\n"
+                          "Entering targetcli batch mode for daemonized approach.\n"
+                          "Enter multiple commands separated by newline and "
+                          "type 'exit' to run them all in one go.\n")
+
+    prompt_path = "/"
+    if interactive:
+        prompt_path = call_daemon(shell, None, interactive)  # get the initial path
+
+    inputs = []
+    real_exit = False
+    while True:
+        command = input(f"{prompt_path}> ")
+        if command.lower() == "exit":
+            real_exit = True
+        elif not command:
+            continue
+        if not interactive:
+            inputs.append(command)
+            if real_exit:
+                command = '%'.join(inputs)  # delimit multiple commands with '%'
+                call_daemon(shell, command, interactive)
+                break
+        else:
+            if real_exit:
+                break
+            path = call_daemon(shell, command, interactive)
+            if path:
+                if path[0] == "/":
+                    prompt_path = path
+                else:
+                    print(path)  # Error No Path ...
+
+    sys.exit(0)
+
+def main():
+    '''
+    Start the targetcli shell.
+    '''
+    shell = TargetCLI(getenv("TARGETCLI_HOME", '~/.targetcli'))
+
+    is_root = False
+    if getuid() == 0:
+        is_root = True
+
+    try:
+        lkfd = open(lock_file, 'w+')  # noqa: SIM115
+    except OSError as e:
+        shell.con.display(
+                shell.con.render_text(f"opening lockfile failed: {e!s}",
+                    'red'))
+        sys.exit(1)
+
+    try_op_lock(shell, lkfd)
+
+    use_daemon = False
+    if shell.prefs['auto_use_daemon']:
+        use_daemon = True
+
+    disable_daemon = False
+    if len(sys.argv) > 1:
+        usage_version(sys.argv[1])
+        if sys.argv[1] in {"disable-daemon", "--disable-daemon"}:
+            disable_daemon = True
+
+    interactive_mode = True
+    if shell.prefs['daemon_use_batch_mode']:
+        interactive_mode = False
+
+    if use_daemon and not disable_daemon:
+        switch_to_daemon(shell, interactive_mode)
+        # does not return
+
+    try:
+        root_node = UIRoot(shell, as_root=is_root)
+        root_node.refresh()
+    except Exception as error:
+        shell.con.display(shell.con.render_text(str(error), 'red'))
+        if not is_root:
+            shell.con.display(shell.con.render_text("Retry as root.", 'red'))
+        sys.exit(-1)
+
+    if len(sys.argv) > 1:
+        try:
+            if disable_daemon:
+                shell.run_cmdline('set global auto_use_daemon=false')
+            else:
+                shell.run_cmdline(" ".join(sys.argv[1:]))
+        except Exception as e:
+            print(str(e), file=sys.stderr)
+            sys.exit(1)
+        sys.exit(0)
+
+    shell.con.display(f"targetcli shell version {targetcli_version}\n"
+                      "Copyright 2011-2013 by Datera, Inc and others.\n"
+                      "For help on commands, type 'help'.\n")
+    if not is_root:
+        shell.con.display("You are not root, disabling privileged commands.\n")
+
+    while not shell._exit:
+        try:
+            shell.run_interactive()
+        except (RTSLibError, ExecutionError) as msg:  # noqa: PERF203 - would otherwise exit shell
+            shell.log.error(str(msg))
+
+    if shell.prefs['auto_save_on_exit'] and is_root:
+        shell.log.info("Global pref auto_save_on_exit=true")
+        root_node.ui_command_saveconfig()
+
+    release_op_lock(shell, lkfd)
+
+
+if __name__ == "__main__":
+    with contextlib.suppress(KeyboardInterrupt):
+        main()

targetcli/targetclid.py

@@ -0,0 +1,281 @@
+'''
+targetclid
+
+This file is part of targetcli-fb.
+Copyright (c) 2019 by Red Hat, Inc.
+
+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 contextlib
+import errno
+import fcntl
+import os
+import signal
+import socket
+import stat
+import struct
+import sys
+import tempfile
+from os import getenv, getuid
+from pathlib import Path
+from threading import Thread
+
+from configshell_fb import ConfigShell
+
+from targetcli import __version__ as targetcli_version
+from targetcli.ui_root import UIRoot
+
+err = sys.stderr
+
+class TargetCLI:
+    def __init__(self):
+        '''
+        initializer
+        '''
+        # socket for unix communication
+        self.socket_path = '/var/run/targetclid.sock'
+        # pid file for defending on multiple daemon runs
+        self.pid_file = '/var/run/targetclid.pid'
+
+        self.NoSignal = True
+        self.sock = None
+
+        # shell console methods
+        self.shell = ConfigShell(getenv("TARGETCLI_HOME", '~/.targetcli'))
+        self.con = self.shell.con
+        self.display = self.shell.con.display
+        self.render = self.shell.con.render_text
+
+        # Handle SIGINT SIGTERM SIGHUP gracefully
+        signal.signal(signal.SIGINT, self.signal_handler)
+        signal.signal(signal.SIGTERM, self.signal_handler)
+        signal.signal(signal.SIGHUP, self.signal_handler)
+
+        try:
+            self.pfd = open(self.pid_file, 'w+')  # noqa: SIM115
+        except OSError as e:
+            self.display(
+                self.render(f"opening pidfile failed: {e!s}", 'red'),
+            )
+            sys.exit(1)
+
+        self.try_pidfile_lock()
+
+        is_root = False
+        if getuid() == 0:
+            is_root = True
+
+        try:
+            root_node = UIRoot(self.shell, as_root=is_root)
+            root_node.refresh()
+        except Exception as error:
+            self.display(self.render(str(error), 'red'))
+            if not is_root:
+                self.display(self.render("Retry as root.", 'red'))
+            self.pfd.close()
+            sys.exit(1)
+
+        # Keep track, for later use
+        self.con_stdout_ = self.con._stdout
+        self.con_stderr_ = self.con._stderr
+
+
+    def __del__(self):
+        '''
+        destructor
+        '''
+        if hasattr(self, 'pfd'):
+            self.pfd.close()
+
+
+    def signal_handler(self):
+        '''
+        signal handler
+        '''
+        self.NoSignal = False
+        if self.sock:
+            self.sock.close()
+
+
+    def try_pidfile_lock(self):
+        '''
+        get lock on pidfile, which is to check if targetclid is running
+        '''
+        # check if targetclid is already running
+        lock = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)
+        try:
+            fcntl.fcntl(self.pfd, fcntl.F_SETLK, lock)
+        except Exception:
+            self.display(self.render("targetclid is already running...", 'red'))
+            self.pfd.close()
+            sys.exit(1)
+
+
+    def release_pidfile_lock(self):
+        '''
+        release lock on pidfile
+        '''
+        lock = struct.pack('hhllhh', fcntl.F_UNLCK, 0, 0, 0, 0, 0)
+        try:
+            fcntl.fcntl(self.pfd, fcntl.F_SETLK, lock)
+        except Exception as e:
+            self.display(
+                self.render(f"fcntl(UNLCK) on pidfile failed: {e!s}", 'red'),
+            )
+            self.pfd.close()
+            sys.exit(1)
+        self.pfd.close()
+
+
+    def client_thread(self, connection):
+        '''
+        Handle commands from client
+        '''
+        # load the prefs
+        self.shell.prefs.load()
+
+        still_listen = True
+        # Receive the data in small chunks and retransmit it
+        while still_listen:
+            data = connection.recv(65535)
+            if b'-END@OF@DATA-' in data:
+                connection.close()
+                still_listen = False
+            else:
+                self.con._stdout = self.con._stderr = f = tempfile.NamedTemporaryFile(mode='w', delete=False)
+                try:
+                    # extract multiple commands delimited with '%'
+                    list_data = data.decode().split('%')
+                    for cmd in list_data:
+                        self.shell.run_cmdline(cmd)
+                except Exception as e:
+                    print(str(e), file=f)  # push error to stream
+
+                # Restore
+                self.con._stdout = self.con_stdout_
+                self.con._stderr = self.con_stderr_
+                f.close()
+
+                with open(f.name) as f:
+                    output = f.read()
+                    var = struct.pack('i', len(output))
+                    connection.sendall(var)  # length of string
+                    if len(output):
+                        connection.sendall(output.encode())  # actual string
+
+                Path(f.name).unlink()
+
+
+def usage():
+    print(f"Usage: {sys.argv[0]} [--version|--help]", file=err)
+    print("  --version\t\tPrint version", file=err)
+    print("  --help\t\tPrint this information", file=err)
+    sys.exit(0)
+
+
+def version():
+    print(f"{sys.argv[0]} version {targetcli_version}", file=err)
+    sys.exit(0)
+
+
+def usage_version(cmd):
+    if cmd in {"help", "--help", "-h"}:
+        usage()
+
+    if cmd in {"version", "--version", "-v"}:
+        version()
+
+
+def main():
+    '''
+    start targetclid
+    '''
+    if len(sys.argv) > 1:
+        usage_version(sys.argv[1])
+        print(f"unrecognized option: {sys.argv[1]}")
+        sys.exit(-1)
+
+    to = TargetCLI()
+
+    if getenv('LISTEN_PID'):
+        # the systemd-activation path, using next available FD
+        fn = sys.stderr.fileno() + 1
+        try:
+            sock = socket.fromfd(fn, socket.AF_UNIX, socket.SOCK_STREAM)
+        except OSError as err:
+            to.display(to.render(err.strerror, 'red'))
+            sys.exit(1)
+
+        # save socket so a signal can clea it up
+        to.sock = sock
+    else:
+        # Make sure file doesn't exist already
+        with contextlib.suppress(FileNotFoundError):
+            Path(to.socket_path).unlink()
+
+        # Create a TCP/IP socket
+        try:
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        except OSError as err:
+            to.display(to.render(err.strerror, 'red'))
+            sys.exit(1)
+
+        # save socket so a signal can clea it up
+        to.sock = sock
+
+        mode = stat.S_IRUSR | stat.S_IWUSR  # 0o600
+        umask = 0o777 ^ mode  # Prevents always downgrading umask to 0
+        umask_original = os.umask(umask)
+        # Bind the socket path
+        try:
+            sock.bind(to.socket_path)
+        except OSError as err:
+            to.display(to.render(err.strerror, 'red'))
+            sys.exit(1)
+        finally:
+            os.umask(umask_original)
+
+        # Listen for incoming connections
+        try:
+            sock.listen(1)
+        except OSError as err:
+            to.display(to.render(err.strerror, 'red'))
+            sys.exit(1)
+
+    while to.NoSignal:
+        try:
+            # Wait for a connection
+            connection, _client_address = sock.accept()
+        except OSError as err:
+            if err.errno != errno.EBADF or to.NoSignal:
+                to.display(to.render(err.strerror, 'red'))
+            break
+
+        thread = Thread(target=to.client_thread, args=(connection,))
+        thread.start()
+        try:
+            thread.join()
+        except Exception as error:
+            to.display(to.render(str(error), 'red'))
+
+    to.release_pidfile_lock()
+
+    if not to.NoSignal:
+        to.display(to.render("Signal received, quiting gracefully!", 'green'))
+        sys.exit(0)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()