updates to lxd/docker to work with net_cmd/node_net_cmd

daemon/core/nodes/lxd.py

@@ -2,30 +2,31 @@ import json
 import logging
 import os
 import time
+from tempfile import NamedTemporaryFile
 
 from core import utils
+from core.emulator import distributed
 from core.emulator.enumerations import NodeTypes
 from core.errors import CoreCommandError
 from core.nodes.base import CoreNode
 
 
 class LxdClient(object):
-    def __init__(self, name, image):
+    def __init__(self, name, image, run):
         self.name = name
         self.image = image
+        self.run = run
         self.pid = None
 
     def create_container(self):
-        utils.check_cmd(
-            "lxc launch {image} {name}".format(name=self.name, image=self.image)
-        )
+        self.run("lxc launch {image} {name}".format(name=self.name, image=self.image))
         data = self.get_info()
         self.pid = data["state"]["pid"]
         return self.pid
 
     def get_info(self):
         args = "lxc list {name} --format json".format(name=self.name)
-        output = utils.check_cmd(args)
+        output = self.run(args)
         data = json.loads(output)
         if not data:
             raise CoreCommandError(
@@ -41,20 +42,16 @@ class LxdClient(object):
             return False
 
     def stop_container(self):
-        utils.check_cmd("lxc delete --force {name}".format(name=self.name))
+        self.run("lxc delete --force {name}".format(name=self.name))
 
     def create_cmd(self, cmd):
         return "lxc exec -nT {name} -- {cmd}".format(name=self.name, cmd=cmd)
 
-    def check_cmd(self, cmd, wait=True):
-        args = self.create_cmd(cmd)
-        return utils.check_cmd(args, wait=wait)
-
     def create_ns_cmd(self, cmd):
         return "nsenter -t {pid} -m -u -i -p -n {cmd}".format(pid=self.pid, cmd=cmd)
 
-    def ns_check_cmd(self, cmd, wait=True):
-        args = self.create_ns_cmd(cmd)
+    def check_cmd(self, cmd, wait=True):
+        args = self.create_cmd(cmd)
         return utils.check_cmd(args, wait=wait)
 
     def copy_file(self, source, destination):
@@ -64,7 +61,7 @@ class LxdClient(object):
         args = "lxc file push {source} {name}/{destination}".format(
             source=source, name=self.name, destination=destination
         )
-        utils.check_cmd(args)
+        self.run(args)
 
 
 class LxcNode(CoreNode):
@@ -115,7 +112,7 @@ class LxcNode(CoreNode):
             if self.up:
                 raise ValueError("starting a node that is already up")
             self.makenodedir()
-            self.client = LxdClient(self.name, self.image)
+            self.client = LxdClient(self.name, self.image, self.net_cmd)
             self.pid = self.client.create_container()
             self.up = True
 
@@ -134,12 +131,6 @@ class LxcNode(CoreNode):
             self.client.stop_container()
             self.up = False
 
-    def node_net_cmd(self, args, wait=True):
-        if not self.up:
-            logging.debug("node down, not running network command: %s", args)
-            return ""
-        return self.client.check_cmd(args, wait)
-
     def termcmdstring(self, sh="/bin/sh"):
         """
         Create a terminal command string.
@@ -147,7 +138,7 @@ class LxcNode(CoreNode):
         :param str sh: shell to execute command in
         :return: str
         """
-        return "lxc exec {name} -- bash".format(name=self.name)
+        return "lxc exec {name} -- {sh}".format(name=self.name, sh=sh)
 
     def privatedir(self, path):
         """
@@ -158,7 +149,7 @@ class LxcNode(CoreNode):
         """
         logging.info("creating node dir: %s", path)
         args = "mkdir -p {path}".format(path=path)
-        return self.client.check_cmd(args)
+        return self.node_net_cmd(args)
 
     def mount(self, source, target):
         """
@@ -181,13 +172,23 @@ class LxcNode(CoreNode):
         :param int mode: mode for file
         :return: nothing
         """
-        logging.debug("node dir(%s) ctrlchannel(%s)", self.nodedir, self.ctrlchnlname)
         logging.debug("nodefile filename(%s) mode(%s)", filename, mode)
-        file_path = os.path.join(self.nodedir, filename)
-        with open(file_path, "w") as f:
-            os.chmod(f.name, mode)
-            f.write(contents)
-        self.client.copy_file(file_path, filename)
+
+        directory = os.path.dirname(filename)
+        temp = NamedTemporaryFile(delete=False)
+        temp.write(contents.encode("utf-8"))
+        temp.close()
+
+        if directory:
+            self.node_net_cmd("mkdir -m %o -p %s" % (0o755, directory))
+        if self.server is not None:
+            distributed.remote_put(self.server, temp.name, temp.name)
+        self.client.copy_file(temp.name, filename)
+        self.node_net_cmd("chmod %o %s" % (mode, filename))
+        if self.server is not None:
+            self.net_cmd("rm -f %s" % temp.name)
+        os.unlink(temp.name)
+        logging.debug("node(%s) added file: %s; mode: 0%o", self.name, filename, mode)
 
     def nodefilecopy(self, filename, srcfilename, mode=None):
         """
@@ -202,7 +203,18 @@ class LxcNode(CoreNode):
         logging.info(
             "node file copy file(%s) source(%s) mode(%s)", filename, srcfilename, mode
         )
-        raise Exception("not supported")
+        directory = os.path.dirname(filename)
+        self.node_net_cmd("mkdir -p %s" % directory)
+
+        if self.server is None:
+            source = srcfilename
+        else:
+            temp = NamedTemporaryFile(delete=False)
+            source = temp.name
+            distributed.remote_put(self.server, source, temp.name)
+
+        self.client.copy_file(source, filename)
+        self.node_net_cmd("chmod %o %s" % (mode, filename))
 
     def addnetif(self, netif, ifindex):
         super(LxcNode, self).addnetif(netif, ifindex)