def setUp(self):
arg = {"host": "localhost", "user": "******", "password": "******"}
stub = "/tmp/service_stub.py"
## service interface
self.__service = ServiceTestUtils("python " + stub, **arg)
## remote interface
self.__interface = RemoteInterfaceImpl(**arg)
## env.yml parameter
self.__parameter = {"servers":[{"name": "s1", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.1/24", "gw": "192.168.0.254/24"}]}, {"name": "s2", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.2/24"}, {"dev": "eth1", "IP": "192.168.1.2/24", "gw": "192.168.1.254/24"}]}]}
## test utils
self.__utils = DockerContainerTestUtils(**arg)
## environment definition file
self.__filename = "/tmp/env.yml"
# make service stub script
f = open(stub, "w")
f.write("import sys\n")
f.write("sys.path.append('/vagrant')\n")
f.write("from dockerEE.service import EnvironmentEmulationService\n")
f.write("service = EnvironmentEmulationService('localhost', 'vagrant', 'vagrant')\n")
f.write("service.action()")
f.close()
# make env.yml
f = open(self.__filename, "w")
f.write("---\n")
f.write("servers:\n")
for p in self.__parameter["servers"]:
f.write(" - name: " + p["name"] + "\n")
f.write(" image: " + p["image"] + "\n")
f.write(" IPs:\n")
for n in p["IPs"]:
f.write(" - dev: " + n["dev"] + "\n")
f.write(" IP: " + n["IP"] + "\n")
if "gw" in n:
f.write(" gw: " + n["gw"] + "\n")
f.close()
def setUp(self):
arg = {"host": "localhost", "user": "******", "password": "******"}
## remote interface
self.__interface = RemoteInterfaceImpl(**arg)
## container_manager
self.__manager = ContainerManagerImpl(**arg)
## test utils
self.__utils = DockerContainerTestUtils(**arg)
class TestEnvironmentEmulationService(unittest.TestCase):
## init test case
# @param self The object pointer
def setUp(self):
arg = {"host": "localhost", "user": "******", "password": "******"}
stub = "/tmp/service_stub.py"
## service interface
self.__service = ServiceTestUtils("python " + stub, **arg)
## remote interface
self.__interface = RemoteInterfaceImpl(**arg)
## env.yml parameter
self.__parameter = {"servers":[{"name": "s1", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.1/24", "gw": "192.168.0.254/24"}]}, {"name": "s2", "image": "local/centos", "IPs": [{"dev": "eth0", "IP": "192.168.0.2/24"}, {"dev": "eth1", "IP": "192.168.1.2/24", "gw": "192.168.1.254/24"}]}]}
## test utils
self.__utils = DockerContainerTestUtils(**arg)
## environment definition file
self.__filename = "/tmp/env.yml"
# make service stub script
f = open(stub, "w")
f.write("import sys\n")
f.write("sys.path.append('/vagrant')\n")
f.write("from dockerEE.service import EnvironmentEmulationService\n")
f.write("service = EnvironmentEmulationService('localhost', 'vagrant', 'vagrant')\n")
f.write("service.action()")
f.close()
# make env.yml
f = open(self.__filename, "w")
f.write("---\n")
f.write("servers:\n")
for p in self.__parameter["servers"]:
f.write(" - name: " + p["name"] + "\n")
f.write(" image: " + p["image"] + "\n")
f.write(" IPs:\n")
for n in p["IPs"]:
f.write(" - dev: " + n["dev"] + "\n")
f.write(" IP: " + n["IP"] + "\n")
if "gw" in n:
f.write(" gw: " + n["gw"] + "\n")
f.close()
## test "python service.py start/stop"
# @param self The object pointer
def testStartStop(self):
servers = [x["name"] for x in self.__parameter["servers"]]
ret = self.__service.start(self.__filename, 10)
self.assertTrue(self.__utils.checkContainerExist(servers))
for p in self.__parameter["servers"]:
for n in p["IPs"]:
ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip addr show")
self.assertTrue(re.search(r"inet " + n["IP"] + ".*" + n["dev"], ret.stdout))
if "gw" in n:
ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip route show")
self.assertIn("default via " + n["gw"].split("/")[0] + " dev " + n["dev"], ret.stdout)
self.__service.stop(10)
self.assertTrue(self.__utils.checkContainerNotExist(servers))
## test "python service.py status"
# @param self The object pointer
def testStatus(self):
servers = [x["name"] for x in self.__parameter["servers"]]
self.__service.start(self.__filename, 10)
ret = self.__service.status()
status = "servers\n"
for p in self.__parameter["servers"]:
status += "\t" + p["name"] + "\n"
for n in p["IPs"]:
status += "\t\t" + n["dev"] + " : " + n["IP"]
if "gw" in n:
status += " via " + n["gw"] + "\n"
else:
status += "\n"
ret.stdout += "\n"
self.assertIn(status, ret.stdout)
self.__service.stop(10)
ret = self.__service.status()
self.assertEqual(ret.rc, 0)
## test "python service.py reload"
# @param self The object pointer
def testReload(self):
servers = [x["name"] for x in self.__parameter["servers"]]
self.__service.start(self.__filename, 10)
for s in servers:
self.__interface.sudo("docker exec -i " + s + " touch /tmp/hello_dockerEE")
for s in servers:
ret = self.__interface.sudo("docker exec -i " + s + " test -f /tmp/hello_dockerEE", True)
self.assertEqual(ret.rc, 0)
self.__service.reload(servers[1:])
ret = self.__interface.sudo("docker exec -i " + servers[0] + " test -f /tmp/hello_dockerEE", True)
self.assertEqual(ret.rc, 0)
ret = self.__interface.sudo("docker exec -i " + servers[1] + " test -f /tmp/hello_dockerEE", True)
self.assertEqual(ret.rc, 1)
for p in self.__parameter["servers"]:
for n in p["IPs"]:
ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip addr show")
self.assertTrue(re.search(r"inet " + n["IP"] + ".*" + n["dev"], ret.stdout))
if "gw" in n:
ret = self.__interface.sudo("docker exec -i " + p["name"] + " ip route show")
self.assertIn("default via " + n["gw"].split("/")[0] + " dev " + n["dev"], ret.stdout)
self.__service.stop(10)
class TestServer(unittest.TestCase):
## init test case
# @param self The object pointer
def setUp(self):
arg = {"host": "localhost", "user": "******", "password": "******"}
## remote interface
self.__interface = RemoteInterfaceImpl(**arg)
## container manager
self.__container_manager = ContainerManagerImpl(**arg)
## host OS manager
self.__host_manager = HostManagerImpl(**arg)
## test utils
self.__utils = DockerContainerTestUtils(**arg)
## test Server.__init__(self, container_manager, name)
# @param self The object pointer
def testInit(self):
server = "s1"
s1 = Server(self.__container_manager, server)
self.assertTrue(self.__utils.checkContainerExist(server))
## test Server.__del__(self)
# @param self The object pointer
def testDel(self):
servers = ["s1", "s2"]
s = [Server(self.__container_manager, _s) for _s in servers]
self.assertTrue(self.__utils.checkContainerExist(servers))
del s[:]
self.assertFalse(self.__utils.checkContainerExist(servers))
## test Server.__del__(self) with IP
# @param self The object pointer
def testDestroyIP(self):
server_info = [{"name": "s1", "ip": ip_interface(u"192.168.0.1/24")}, {"name": "s2", "ip": ip_interface(u"192.168.0.2/24")}]
servers = []
for s in server_info:
servers.append(Server(self.__container_manager, s["name"]))
servers[-1].attachIP(self.__host_manager, "eth0", s["ip"])
self.assertTrue(self.__utils.checkContainerExist([s["name"] for s in server_info]))
self.assertIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout)
del servers[0]
self.assertIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout)
del servers[0]
self.assertNotIn("br_192.168.0.0", self.__interface.sudo("ip addr show").stdout)
## test Server.getNetworkInfo(self)
# @param self The object pointer
def testGetNetworkInfo(self):
network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}]
s1 = Server(self.__container_manager, "s1")
for n in network:
if n["gw"] is not None:
s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"])
else:
s1.attachIP(self.__host_manager, n["dev"], n["IP"])
self.assertEqual(s1.getNetworkInfo(), network)
## test Server.command(command)
# @param self The object pointer
def testCommand(self):
server = "s1"
s1 = Server(self.__container_manager, server)
ret = s1.command("uname -n")
self.assertEqual(s1.command("uname -n").stdout, server)
## test Server.attachIP(host_manager, dev, IP, gw)
# @param self The object pointer
def testAttachIP(self):
network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}]
s1 = Server(self.__container_manager, "s1")
for n in network:
if n["gw"] is not None:
s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"])
else:
s1.attachIP(self.__host_manager, n["dev"], n["IP"])
ret = s1.command("ip addr show")
for n in network:
self.assertTrue(re.search(r"inet " + str(n["IP"]) + ".*" + n["dev"], ret.stdout))
ret = s1.command("ip route show")
for n in network:
if n["gw"] is not None:
self.assertIn("default via " + str(n["gw"].ip) + " dev " + n["dev"], ret.stdout)
## test Server.reload(self)
# @param self The object pointer
def testReload(self):
s1 = Server(self.__container_manager, "s1")
ret = s1.command("touch /tmp/hello_dockerEE")
self.assertEqual(ret.rc, 0)
ret = s1.command("test -f /tmp/hello_dockerEE")
self.assertEqual(ret.rc, 0)
s1.reload(self.__container_manager, self.__host_manager)
with self.assertRaises(RuntimeError):
ret = s1.command("test -f /tmp/hello_dockerEE")
## test Server.reload(self, options)
# @param self The object pointer
def testReloadOptions(self):
image = "centos:6"
s1 = Server(self.__container_manager, "s1", source=image)
s1.reload(self.__container_manager, self.__host_manager)
self.assertIn(image, self.__interface.sudo("docker ps -a").stdout.splitlines()[1].split())
## test Server.reload(self) with IP
# @param self The object pointer
def testReloadIP(self):
network = [{"dev": "eth0", "IP": ip_interface(u"192.168.0.1/24"), "gw": None}, {"dev": "eth1", "IP": ip_interface(u"192.168.1.2/24"), "gw": ip_interface(u"192.168.1.254/24")}]
s1 = Server(self.__container_manager, "s1")
for n in network:
if n["gw"] is not None:
s1.attachIP(self.__host_manager, n["dev"], n["IP"], n["gw"])
else:
s1.attachIP(self.__host_manager, n["dev"], n["IP"])
s1.reload(self.__container_manager, self.__host_manager)
ret = s1.command("ip addr show")
for n in network:
self.assertTrue(re.search(r"inet " + str(n["IP"]) + ".*" + n["dev"], ret.stdout))
ret = s1.command("ip route show")
for n in network:
if n["gw"] is not None:
self.assertIn("default via " + str(n["gw"].ip) + " dev " + n["dev"], ret.stdout)
class TestContainerManagerImpl(unittest.TestCase):
## init test case
# @param self The object pointer
def setUp(self):
arg = {"host": "localhost", "user": "******", "password": "******"}
## remote interface
self.__interface = RemoteInterfaceImpl(**arg)
## container_manager
self.__manager = ContainerManagerImpl(**arg)
## test utils
self.__utils = DockerContainerTestUtils(**arg)
## test ContainerManagerImpl.create(name)
# @param self The object pointer
def testCreate(self):
container = "c1"
c = self.__manager.create(container)
self.assertTrue(self.__utils.checkContainerExist(container))
## test ContainerManagerImpl.create(name. privilege)
# @param self The object pointer
def testCreateWithPrivilege(self):
container = "c1"
c = self.__manager.create(container, privilege=["NET_ADMIN", "SYS_ADMIN"])
ret = self.__interface.sudo("docker exec -i " + container + " umount /etc/hosts")
self.assertEqual(ret.rc, 0)
## test ContainerManagerImpl.create(name, hosts)
# @param self The object pointer
def testCreateWithHosts(self):
container = "c1"
hosts = [{"name": "c1", "IP": "1.0.1.10"}, {"name": "c2", "IP": "1.0.1.11"}]
c = self.__manager.create(container, hosts=hosts)
ret = self.__interface.sudo("docker exec -i " + container + " cat /etc/hosts")
container_hosts = ret.stdout.splitlines()[-len(hosts):]
for i in range(len(hosts)):
container_host = container_hosts[i].split()
host = hosts[i]
self.assertEqual(container_host[1], host["name"])
self.assertEqual(container_host[0], host["IP"])
## test ContainerManagerImpl.create(name, image)
# @param self The object pointer
def testCreateWithImage(self):
container = "c1"
image = "centos:6"
c = self.__manager.create(container, image=image)
ret = self.__interface.sudo("docker ps -a")
lines = ret.stdout.splitlines()
self.assertIn(image, lines[1].split())
## test ContainerManagerImpl.destroyContainerImpl(container)
# @param self The object pointer
def testDestroy(self):
container = "c1"
c = self.__manager.create(container)
self.assertTrue(self.__utils.checkContainerExist(container))
del c
self.assertTrue(self.__utils.checkContainerNotExist(container))
## test ContainerManagerImpl.command(container, command)
# @param self The object pointer
def testCommand(self):
container = "c1"
c = self.__manager.create(container)
ret = c.command("uname -n")
self.assertEqual(ret.stdout, container)
## test ContainerManagerImpl.attachIP(container, segment, dev, IP, gw)
# @param self The object pointer
def testAttachIP(self):
bridge = "br1"
self.__interface.sudo("brctl addbr " + bridge)
self.__interface.sudo("ip link set " + bridge + " up")
container = "c1"
c = self.__manager.create(container)
ip1 = ip_interface(u"192.168.0.1/24")
dev1 = "eth0"
c.attachIP(bridge, dev1, ip1)
ret = c.command("ip addr show")
self.assertTrue(re.search(r"inet " + str(ip1) + ".*" + dev1, ret.stdout))
ip2 = ip_interface(u"192.168.1.1/24")
dev2 = "eth1"
gw = ip_interface(u"192.168.1.254/24")
c.attachIP(bridge, dev2, ip2, gw)
ret = c.command("ip addr show")
self.assertTrue(re.search(r"inet " + str(ip2) + ".*" + dev2, ret.stdout))
ret = c.command("ip route show")
self.assertIn("default via " + str(gw.ip) + " dev " + dev2, ret.stdout)
self.__interface.sudo("ip link set " + bridge + " down")
self.__interface.sudo("brctl delbr " + bridge)
## test ContainerManagerImpl.__init__(host, user, password) fails because docker service is not running
# @param self The object pointer
def testFailInit(self):
self.__interface.sudo("service docker stop")
with self.assertRaises(RuntimeError):
self.setUp()
self.__interface.sudo("service docker start")
## test ContainerManagerImpl.create(name) fails because docker service is not running
# @param self The object pointer
def testFailCreate(self):
self.__interface.sudo("service docker stop")
with self.assertRaises(RuntimeError):
self.__manager.create("c1")
self.__interface.sudo("service docker start")
## test ContainerManagerImpl.command(container, command) fails because the command does not exist
# @param self The object pointer
def testFailCommand(self):
container = "c1"
c = self.__manager.create(container)
with self.assertRaises(RuntimeError):
c.command("fail")
## test ContainerManagerImpl.attachIP(container, segment, dev, IP) fails bacause the same dev is already attached
# @param self The object pointer
def testFailAttachIP(self):
bridge = "br1"
self.__interface.sudo("brctl addbr " + bridge)
self.__interface.sudo("ip link set " + bridge + " up")
container = "c1"
c = self.__manager.create(container)
ip = ip_interface(u"192.168.0.1/24")
dev = "eth0"
c.attachIP(bridge, dev, ip)
with self.assertRaises(RuntimeError):
c.attachIP(bridge, dev, ip)
self.__interface.sudo("ip link set " + bridge + " down")
self.__interface.sudo("brctl delbr " + bridge)
