path: root/daemon/targetclid

#!/usr/bin/python

'''
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.
'''

from __future__ import print_function
from targetcli import UIRoot
from targetcli import __version__ as targetcli_version
from configshell_fb import ConfigShell
from os import getuid, getenv, unlink
from threading import Thread

import sys
import socket
import struct
import fcntl
import signal


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

        # 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+')
        except IOError as e:
            self.display(
                self.render(
                    "opening pidfile failed: %s" %str(e),
                    '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, signum, frame):
        '''
        signal handler
        '''
        self.NoSignal = False


    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(
                    "fcntl(UNLCK) on pidfile failed: %s" %str(e),
                    'red'))
            self.pfd.close()
            sys.exit(1)
        self.pfd.close()


    def client_thread(self, connection):
        '''
        Handle commands from client
        '''
        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 = open("/tmp/data.txt", "w")
                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('/tmp/data.txt', 'r') 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


def usage():
    print("Usage: %s [--version|--help]" % sys.argv[0], file=err)
    print("  --version\t\tPrint version", file=err)
    print("  --help\t\tPrint this information", file=err)
    sys.exit(0)


def version():
    print("%s version %s" % (sys.argv[0], 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("unrecognized option: %s" % (sys.argv[1]))
        sys.exit(-1)

    to = TargetCLI()

    # Make sure file doesn't exist already
    try:
        unlink(to.socket_path)
    except:
        pass

    # Create a TCP/IP socket
    try:
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    except socket.error as err:
        to.display(to.render(err.strerror, 'red'))
        sys.exit(1)

    # Bind the socket path
    try:
        sock.bind(to.socket_path)
    except socket.error as err:
        to.display(to.render(err.strerror, 'red'))
        sys.exit(1)

    # Listen for incoming connections
    try:
        sock.listen(1)
    except socket.error 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 socket.error as err:
            to.display(to.render(err.strerror, 'red'))
            break

        thread = Thread(target=to.client_thread, args=(connection,))
        thread.start()
        try:
            thread.join()
        except:
            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(1)


if __name__ == "__main__":
    main()