Merge branch 'core-testing'

setup.py

@@ -57,4 +57,5 @@ setup(name=name,
           'slapproxy = slapos.proxy:main',
         ]
       },
+      test_suite="slapos.tests",
     )

slapos/format.py

@@ -27,13 +27,13 @@
 ##############################################################################
 from optparse import OptionParser, Option
 from xml_marshaller import xml_marshaller
-from pwd import getpwnam
 import ConfigParser
 import grp
 import logging
 import netaddr
 import netifaces
 import os
+import pwd
 import random
 import slapos.slap as slap
 import socket
@@ -317,7 +317,7 @@ class Computer:
     slapsoft.path = self.software_root
     if alter_user:
       slapsoft.create()
-      slapsoft_pw = getpwnam(slapsoft.name)
+      slapsoft_pw = pwd.getpwnam(slapsoft.name)
       os.chown(self.software_root, slapsoft_pw.pw_uid, slapsoft_pw.pw_gid)
     os.chmod(self.software_root, 0755)
 
@@ -415,7 +415,7 @@ class Partition:
     if not os.path.exists(self.path):
       os.mkdir(self.path, 0750)
     if alter_user:
-      owner_pw = getpwnam(owner.name)
+      owner_pw = pwd.getpwnam(owner.name)
       os.chown(self.path, owner_pw.pw_uid, owner_pw.pw_gid)
     os.chmod(self.path, 0750)
 
@@ -457,7 +457,7 @@ class User:
       user_parameter_list.extend(['-G', ','.join(self.additional_group_list)])
     user_parameter_list.append(self.name)
     try:
-      getpwnam(self.name)
+      pwd.getpwnam(self.name)
     except KeyError:
       callAndRead(['useradd'] + user_parameter_list)
     else:
@@ -475,7 +475,7 @@ class User:
     """
 
     try:
-      getpwnam(self.name)
+      pwd.getpwnam(self.name)
       return True
 
     except KeyError:
@@ -572,7 +572,7 @@ class Tap:
         owner_id = int(open(check_file).read().strip())
       except Exception:
         pass
-    if (owner_id is None) or (owner_id != getpwnam(owner.name).pw_uid):
+    if (owner_id is None) or (owner_id != pwd.getpwnam(owner.name).pw_uid):
       callAndRead(['tunctl', '-t', self.name, '-u', owner.name])
     callAndRead(['ip', 'link', 'set', self.name, 'up'])
 
@@ -584,7 +584,7 @@ class Tap:
 class Bridge:
   "Bridge represent a bridge on the system"
 
-  def __init__(self, name, ipv4_local_network, ipv6_interface):
+  def __init__(self, name, ipv4_local_network, ipv6_interface=None):
     """
     Attributes:
         name: String, the name of the bridge
@@ -846,10 +846,13 @@ class Parser(OptionParser):
         help="Shall slapformat alter network configuration [default: True]"),
       ])
 
-  def check_args(self):
+  def check_args(self, args):
     """
     Check arguments
     """
+    if args:
+      (options, args) = self.parse_args(list(args))
+    else:
       (options, args) = self.parse_args()
     if len(args) != 1:
       self.error("Incorrect number of arguments")
@@ -1093,17 +1096,17 @@ class Config:
     self.computer_xml = os.path.abspath(self.computer_xml)
 
 
-def main():
+def main(*args):
   "Run default configuration."
   global os
   global callAndRead
-  global getpwnam
+  global pwd
   real_callAndRead = callAndRead
   usage = "usage: %s [options] CONFIGURATION_FILE" % sys.argv[0]
 
   try:
     # Parse arguments
-    options, configuration_file_path = Parser(usage=usage).check_args()
+    options, configuration_file_path = Parser(usage=usage).check_args(args)
     config = Config()
     config.setConfig(options, configuration_file_path)
     os = OS(config)
@@ -1125,7 +1128,7 @@ def main():
           pw_uid = 12345
           pw_gid = 54321
         return result
-      getpwnam = fake_getpwnam
+      pwd.getpwnam = fake_getpwnam
     else:
       dry_callAndRead = real_callAndRead
     if config.verbose:

slapos/grid/slapgrid.py

@@ -337,7 +337,7 @@ class Slapgrid(object):
       computer_partition_list = self.computer.getComputerPartitionList()
     except socket.error as error:
       self.logger.fatal(error)
-      sys.exit(1)
+      raise
     return computer_partition_list
 
   def processSoftwareReleaseList(self):

slapos/tests/mock/httplib.py

+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""Mocked httplib
+"""
+
+from urlparse import urlparse
+
+__all__ = []
+
+def log(message):
+  """Need to be overridden to get a proper logger
+  """
+  pass
+
+class HTTPConnection(object):
+
+  scheme = 'http'
+
+  def _callback(self, path, method, body, headers):
+    """To get it works properly, you need to override
+    HTTPConnection._callback.  This method received the instance, the path,
+    method and request body as parameter, and it has to return a tuple with
+    headers dictionary and body response string.
+    
+    @param self object instance reference
+    @param URL the parsed URL
+    @param method the http method
+    @param body the request body
+    @param headers the request headers
+    
+    @return tuple containing status integer, headers dictionary and body
+    response"""
+    return (0, {}, '', )
+
+  def __init__(self, host, port=None, strict=None,
+               timeout=None, source_address=None):
+    self.host = host
+    self.port = port
+    self.strict = strict
+    self.timeout = timeout
+    self.source_address = source_address
+    self.__response = None
+
+  def request(self, method, url, body=None, headers=None):
+    status, headers, body = self._callback(url, method, body, headers)
+    self.__response = HTTPResponse('HTTP/1.1', 200, 'OK', body, headers)
+
+
+  def getresponse(self):
+    response = self.__response
+    self.__response = None
+    return response
+
+  def set_debuglevel(self, level):
+    pass
+
+  def set_tunnel(self, host, port=None, headers=None):
+    pass
+
+  def connect(self):
+    pass
+
+  def close(self):
+    pass
+
+  def putrequest(self, request, selector, skip_host=None,
+                 skip_accept_encoding=None):
+    pass
+
+  def putheader(self, *args):
+    pass
+
+  def endheaders(self):
+    pass
+
+  def send(self, data):
+    pass
+
+class HTTPSConnection(HTTPConnection):
+
+  def __init__(self, host, port=None, key_file=None,
+               cert_file=None, strict=None, timeout=None,
+               source_address=None):
+    super().__init__(self, host, port, strict, timeout,
+                     source_address)
+    pass
+
+class HTTPResponse(object):
+
+  def __init__(self, version, status, reason, content, headers=()):
+    self.version = version
+    self.status = status
+    self.reason = reason
+    self.__headers = headers
+    self.__content = content
+
+  def read(self, amt=None):
+    result = None
+    if amt is None:
+      result = self.__content
+      self.__content = ''
+    else:
+      end = max(amt, len(self.__content))
+      result = self.__content[:end]
+      del self.__content[:end]
+    return result
+
+  def getheader(self, name, default=None):
+    pass
+
+  def getheaders(self):
+    pass

slapos/tests/slapgrid.py

+from slapos.grid import slapgrid
+import httplib
+import logging
+import os
+import shutil
+import signal
+import slapos.slap.slap
+import socket
+import tempfile
+import unittest
+import urlparse
+import xml_marshaller
+
+class BasicMixin:
+  def assertSortedListEqual(self, list1, list2, msg=None):
+    self.assertListEqual(sorted(list1), sorted(list2), msg)
+
+  def setUp(self):
+    self._tempdir = tempfile.mkdtemp()
+    self.software_root = os.path.join(self._tempdir, 'software')
+    self.instance_root = os.path.join(self._tempdir, 'instance')
+    if getattr(self, 'master_url', None) is None:
+      self.master_url = 'http://127.0.0.1:0/'
+    self.computer_id = 'computer'
+    self.supervisord_socket = os.path.join(self._tempdir, 'supervisord.sock')
+    self.supervisord_configuration_path = os.path.join(self._tempdir,
+      'supervisord')
+    self.usage_report_periodicity = 1
+    self.buildout = None
+    logging.basicConfig(level=logging.DEBUG)
+    self.grid = slapgrid.Slapgrid(self.software_root, self.instance_root,
+      self.master_url, self.computer_id, self.supervisord_socket,
+      self.supervisord_configuration_path, self.usage_report_periodicity,
+      self.buildout)
+
+  def tearDown(self):
+    shutil.rmtree(self._tempdir, True)
+
+class TestBasicSlapgridCP(BasicMixin, unittest.TestCase):
+  def test_no_software_root(self):
+    self.assertRaises(OSError, self.grid.processComputerPartitionList)
+
+  def test_no_instance_root(self):
+    os.mkdir(self.software_root)
+    self.assertRaises(OSError, self.grid.processComputerPartitionList)
+
+  def test_no_master(self):
+    os.mkdir(self.software_root)
+    os.mkdir(self.instance_root)
+    self.assertRaises(socket.error, self.grid.processComputerPartitionList)
+
+class MasterMixin(BasicMixin):
+
+  def _patchHttplib(self):
+    """Overrides httplib"""
+    import mock.httplib
+
+    self.saved_httplib = dict()
+
+    for fake in vars(mock.httplib):
+      self.saved_httplib[fake] = getattr(httplib, fake, None)
+      setattr(httplib, fake, getattr(mock.httplib, fake))
+
+  def _unpatchHttplib(self):
+    """Restores httplib overriding"""
+    import httplib
+    for name, original_value in self.saved_httplib.items():
+      setattr(httplib, name, original_value)
+    del self.saved_httplib
+
+  def setUp(self):
+    self._patchHttplib()
+    BasicMixin.setUp(self)
+
+  def tearDown(self):
+    self._unpatchHttplib()
+    # XXX: Hardcoded pid, as it is not configurable in slapos
+    svc = os.path.join(self.instance_root, 'var', 'run', 'supervisord.pid')
+    if os.path.exists(svc):
+      try:
+        pid = int(open(svc).read().strip())
+      except ValueError:
+        pass
+      else:
+        os.kill(pid, signal.SIGTERM)
+    BasicMixin.tearDown(self)
+
+class TestSlapgridCPWithMaster(MasterMixin, unittest.TestCase):
+
+  def test_nothing_to_do(self):
+
+    def server_response(self, path, method, body, header):
+      parsed_url = urlparse.urlparse(path.lstrip('/'))
+      parsed_qs = urlparse.parse_qs(parsed_url.query)
+      if parsed_url.path == 'getComputerInformation' and \
+         'computer_id' in parsed_qs:
+        slap_computer = slapos.slap.Computer(parsed_qs['computer_id'])
+        slap_computer._software_release_list = []
+        slap_computer._computer_partition_list = []
+        return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer))
+      else:
+        return (404, {}, '')
+
+    httplib.HTTPConnection._callback = server_response
+    os.mkdir(self.software_root)
+    os.mkdir(self.instance_root)
+    self.assertTrue(self.grid.processComputerPartitionList())
+    self.assertSortedListEqual(os.listdir(self.instance_root), ['etc', 'var'])
+    self.assertSortedListEqual(os.listdir(self.software_root), [])
+
+  def test_one_partition(self):
+
+    def server_response(self, path, method, body, header):
+      parsed_url = urlparse.urlparse('/' + path)
+      parsed_qs = urlparse.parse_qs(parsed_url.query)
+      if parsed_url.path == '/getComputerInformation' and \
+         'computer_id' in parsed_qs:
+        slap_computer = slapos.slap.Computer(parsed_qs['computer_id'])
+        slap_computer._software_release_list = []
+        partition = slapos.slap.ComputerPartition(parsed_qs['computer_id'],
+            '0')
+        partition._need_modification = True
+        sr = slapos.slap.SoftwareRelease()
+        sr._software_release = 'http://sr/'
+        partition._software_release_document = sr
+        partition._requested_state = 'stopped'
+        slap_computer._computer_partition_list = [partition]
+        return (200, {}, xml_marshaller.xml_marshaller.dumps(slap_computer))
+      else:
+        return (404, {}, '')
+
+    httplib.HTTPConnection._callback = server_response
+    os.mkdir(self.software_root)
+    os.mkdir(self.instance_root)
+    partition_path = os.path.join(self.instance_root, '0')
+    os.mkdir(partition_path, 0750)
+    software_hash = slapos.grid.utils.getSoftwareUrlHash('http://sr/')
+    srdir = os.path.join(self.software_root, software_hash)
+    os.mkdir(srdir)
+    open(os.path.join(srdir, 'template.cfg'), 'w').write(
+      """[buildout]""")
+    srbindir = os.path.join(srdir, 'bin')
+    os.mkdir(srbindir)
+    open(os.path.join(srbindir, 'buildout'), 'w').write("""#!/bin/sh
+touch worked""")
+    os.chmod(os.path.join(srbindir, 'buildout'), 0755)
+    self.assertTrue(self.grid.processComputerPartitionList())
+    self.assertSortedListEqual(os.listdir(self.instance_root), ['0', 'etc',
+      'var'])
+    self.assertSortedListEqual(os.listdir(self.software_root),
+      [software_hash])