153 lines
4.1 KiB
Python
153 lines
4.1 KiB
Python
"""
|
|
client.py: implementation of the VnodeClient class for issuing commands
|
|
over a control channel to the vnoded process running in a network namespace.
|
|
The control channel can be accessed via calls using the vcmd shell.
|
|
"""
|
|
|
|
import logging
|
|
import os
|
|
from subprocess import PIPE, Popen
|
|
|
|
from core import constants, utils
|
|
from core.errors import CoreCommandError
|
|
|
|
|
|
class VnodeClient(object):
|
|
"""
|
|
Provides client functionality for interacting with a virtual node.
|
|
"""
|
|
|
|
def __init__(self, name, ctrlchnlname):
|
|
"""
|
|
Create a VnodeClient instance.
|
|
|
|
:param str name: name for client
|
|
:param str ctrlchnlname: control channel name
|
|
"""
|
|
self.name = name
|
|
self.ctrlchnlname = ctrlchnlname
|
|
|
|
def _verify_connection(self):
|
|
"""
|
|
Checks that the vcmd client is properly connected.
|
|
|
|
:return: nothing
|
|
:raises IOError: when not connected
|
|
"""
|
|
if not self.connected():
|
|
raise IOError("vcmd not connected")
|
|
|
|
def connected(self):
|
|
"""
|
|
Check if node is connected or not.
|
|
|
|
:return: True if connected, False otherwise
|
|
:rtype: bool
|
|
"""
|
|
return True
|
|
|
|
def close(self):
|
|
"""
|
|
Close the client connection.
|
|
|
|
:return: nothing
|
|
"""
|
|
pass
|
|
|
|
def _cmd_args(self):
|
|
return [constants.VCMD_BIN, "-c", self.ctrlchnlname, "--"]
|
|
|
|
def check_cmd(self, args, wait=True):
|
|
"""
|
|
Run command and return exit status and combined stdout and stderr.
|
|
|
|
:param list[str]|str args: command to run
|
|
:param bool wait: True to wait for command status, False otherwise
|
|
:return: combined stdout and stderr
|
|
:rtype: str
|
|
:raises core.CoreCommandError: when there is a non-zero exit status
|
|
"""
|
|
p, stdin, stdout, stderr = self.popen(args)
|
|
stdin.close()
|
|
output = stdout.read() + stderr.read()
|
|
output = output.decode("utf-8").strip()
|
|
stdout.close()
|
|
stderr.close()
|
|
status = p.wait()
|
|
if wait and status != 0:
|
|
raise CoreCommandError(status, args, output)
|
|
return output
|
|
|
|
def popen(self, args):
|
|
"""
|
|
Execute a popen command against the node.
|
|
|
|
:param list[str]|str args: command arguments
|
|
:return: popen object, stdin, stdout, and stderr
|
|
:rtype: tuple
|
|
"""
|
|
self._verify_connection()
|
|
args = utils.split_args(args)
|
|
cmd = self._cmd_args() + args
|
|
logging.debug("popen: %s", cmd)
|
|
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
|
|
return p, p.stdin, p.stdout, p.stderr
|
|
|
|
def icmd(self, args):
|
|
"""
|
|
Execute an icmd against a node.
|
|
|
|
:param list[str]|str args: command arguments
|
|
:return: command result
|
|
:rtype: int
|
|
"""
|
|
args = utils.split_args(args)
|
|
return os.spawnlp(
|
|
os.P_WAIT,
|
|
constants.VCMD_BIN,
|
|
constants.VCMD_BIN,
|
|
"-c",
|
|
self.ctrlchnlname,
|
|
"--",
|
|
*args
|
|
)
|
|
|
|
def term(self, sh="/bin/sh"):
|
|
"""
|
|
Open a terminal on a node.
|
|
|
|
:param str sh: shell to open terminal with
|
|
:return: terminal command result
|
|
:rtype: int
|
|
"""
|
|
args = (
|
|
"xterm",
|
|
"-ut",
|
|
"-title",
|
|
self.name,
|
|
"-e",
|
|
constants.VCMD_BIN,
|
|
"-c",
|
|
self.ctrlchnlname,
|
|
"--",
|
|
sh,
|
|
)
|
|
if "SUDO_USER" in os.environ:
|
|
args = (
|
|
"su",
|
|
"-s",
|
|
"/bin/sh",
|
|
"-c",
|
|
"exec " + " ".join(map(lambda x: "'%s'" % x, args)),
|
|
os.environ["SUDO_USER"],
|
|
)
|
|
return os.spawnvp(os.P_NOWAIT, args[0], args)
|
|
|
|
def termcmdstring(self, sh="/bin/sh"):
|
|
"""
|
|
Create a terminal command string.
|
|
|
|
:param str sh: shell to execute command in
|
|
:return: str
|
|
"""
|
|
return "%s -c %s -- %s" % (constants.VCMD_BIN, self.ctrlchnlname, sh)
|