Merge lp:~sinzui/juju-release-tools/win-agents into lp:juju-release-tools

[Curtis Hovey]

This branch adds support to create a win amd64 jujud agent each time a win 386 juju client is created.

The changes look more invasive than actual.
1. renamed build => build_client
   and the dir and command constants are passed to the function to make testing easier.
2. renamed package => create_installer
   and the dir and command constants are passed to the function to make testing easier.
3. added build_agent based on build_client
4. added create_cloud_agent
5. added cleanup of old agent files per the way old installers are cleaned up
6. extracted temp_dir() to utils.py to reuse it in new win tests
7. I added tests for the functions I changed and the two new functions I added.

A future branch in juju-ci-tools will change the tests to capture the agent tgz when the installer is captured.

[Aaron Bentley (abentley)]

Looks good.

review: Approve

=== modified file 'tests/test_make_release_notes.py'
--- tests/test_make_release_notes.py	2014-09-18 20:16:00 +0000
+++ tests/test_make_release_notes.py	2014-10-20 19:01:48 +0000
@@ -1,9 +1,6 @@
-from contextlib import contextmanager
 from mock import patch
 import os
-import shutil
 from StringIO import StringIO
-from tempfile import mkdtemp
 from unittest import TestCase
 
 
@@ -18,15 +15,7 @@
     save_notes,
     STABLE,
 )
-
-
-@contextmanager
-def temp_dir():
-    dirname = mkdtemp()
-    try:
-        yield dirname
-    finally:
-        shutil.rmtree(dirname)
+from utils import temp_dir
 
 
 class FakeBug(object):

=== added file 'tests/test_winbuildtest.py'
--- tests/test_winbuildtest.py	1970-01-01 00:00:00 +0000
+++ tests/test_winbuildtest.py	2014-10-20 19:01:48 +0000
@@ -0,0 +1,91 @@
+from mock import patch
+import os
+import tarfile
+from unittest import TestCase
+
+from winbuildtest import (
+    build_agent,
+    build_client,
+    create_cloud_agent,
+    create_installer,
+    GO_CMD,
+    GOPATH,
+    ISS_CMD,
+)
+from utils import temp_dir
+
+
+class WinBuildTestTestCase(TestCase):
+
+    def test_build_client(self):
+        # build_client() builds the juju client with go and moved the
+        # exe to the iss dir.
+        with temp_dir() as cmd_dir:
+            with temp_dir() as iss_dir:
+
+                def make_juju(*args, **kwargs):
+                    with open('%s/juju.exe' % cmd_dir, 'w') as fake_juju:
+                        fake_juju.write('juju')
+
+                with patch('winbuildtest.run',
+                           return_value='', side_effect=make_juju) as run_mock:
+                    devnull = open(os.devnull, 'w')
+                    with patch('sys.stdout', devnull):
+                        build_client(cmd_dir, GO_CMD, GOPATH, iss_dir)
+                        args, kwargs = run_mock.call_args
+                        self.assertEqual((GO_CMD, 'build'), args)
+                        self.assertEqual('386', kwargs['env'].get('GOARCH'))
+                        self.assertEqual(GOPATH, kwargs['env'].get('GOPATH'))
+                        client_path = os.path.join(iss_dir, 'juju.exe')
+                        self.assertTrue(os.path.isfile(client_path))
+
+    def test_create_installer(self):
+        # create_installer() creates an iss-style installer and copies it
+        # to the ci dir.
+        with temp_dir() as iss_dir:
+            with temp_dir() as ci_dir:
+                installer_name = 'juju-setup-1.20.1.exe'
+
+                def make_installer(*args, **kwargs):
+                    output_dir = os.path.join(iss_dir, 'output')
+                    os.makedirs(output_dir)
+                    installer_path = os.path.join(
+                        output_dir, installer_name)
+                    with open(installer_path, 'w') as fake_installer:
+                        fake_installer.write('juju installer')
+
+                with patch('winbuildtest.run',
+                           return_value='',
+                           side_effect=make_installer) as run_mock:
+                    devnull = open(os.devnull, 'w')
+                    with patch('sys.stdout', devnull):
+                        create_installer('1.20.1', iss_dir, ISS_CMD, ci_dir)
+                        args, kwargs = run_mock.call_args
+                        self.assertEqual((ISS_CMD, 'setup.iss'), args)
+                        installer_path = os.path.join(ci_dir, installer_name)
+                        self.assertTrue(os.path.isfile(installer_path))
+
+    def test_build_agent(self):
+        # build_agent creates a win amd64 jujud.
+        with temp_dir() as jujud_cmd_dir:
+            with patch('winbuildtest.run', return_value='') as run_mock:
+                devnull = open(os.devnull, 'w')
+                with patch('sys.stdout', devnull):
+                    build_agent(jujud_cmd_dir, GO_CMD, GOPATH)
+                    args, kwargs = run_mock.call_args
+                    self.assertEqual((GO_CMD, 'build'), args)
+                    self.assertEqual('amd64', kwargs['env'].get('GOARCH'))
+                    self.assertEqual(GOPATH, kwargs['env'].get('GOPATH'))
+
+    def test_create_cloud_agent(self):
+        # create_cloud_agent() creates an agent tgz from the jujud and
+        # copies it to the ci dir.
+        with temp_dir() as cmd_dir:
+            with temp_dir() as ci_dir:
+                with open('%s/jujud.exe' % cmd_dir, 'w') as fake_jujud:
+                    fake_jujud.write('jujud')
+                create_cloud_agent('1.20.1', cmd_dir, ci_dir)
+                agent = os.path.join(ci_dir, 'juju-1.20.1-win2012-amd64.tgz')
+                self.assertTrue(os.path.isfile(agent))
+                with tarfile.open(name=agent, mode='r:gz') as tar:
+                    self.assertEqual(['jujud.exe'], tar.getnames())

=== added file 'tests/utils.py'
--- tests/utils.py	1970-01-01 00:00:00 +0000
+++ tests/utils.py	2014-10-20 19:01:48 +0000
@@ -0,0 +1,12 @@
+from contextlib import contextmanager
+import shutil
+from tempfile import mkdtemp
+
+
+@contextmanager
+def temp_dir():
+    dirname = mkdtemp()
+    try:
+        yield dirname
+    finally:
+        shutil.rmtree(dirname)

=== modified file 'winbuildtest.py'
--- winbuildtest.py	2014-07-07 18:55:30 +0000
+++ winbuildtest.py	2014-10-20 19:01:48 +0000
@@ -22,6 +22,8 @@
 GOPATH = os.path.join(CI_DIR, 'gogo')
 JUJU_CMD_DIR = os.path.join(
     GOPATH, 'src', 'github.com', 'juju', 'juju', 'cmd', 'juju')
+JUJUD_CMD_DIR = os.path.join(
+    GOPATH, 'src', 'github.com', 'juju', 'juju', 'cmd', 'juju')
 ISS_DIR = os.path.join(
     GOPATH, 'src', 'github.com', 'juju', 'juju', 'scripts', 'win-installer')
 
@@ -60,6 +62,11 @@
         path = os.path.join(CI_DIR, name)
         os.remove(path)
         print('Removed {0}'.format(path))
+    agent_tars = [n for n in os.listdir(CI_DIR) if 'tgz' in n]
+    for name in agent_tars:
+        path = os.path.join(CI_DIR, name)
+        os.remove(path)
+        print('Removed {0}'.format(path))
     juju_execs = [
         n for n in os.listdir(CI_DIR) if 'juju-setup' in n and '.exe' in n]
     for name in juju_execs:
@@ -95,26 +102,26 @@
     print('Moved {0} to {1}'.format(dir_path, GOPATH))
 
 
-def build():
+def build_client(juju_cmd_dir, go_cmd, gopath, iss_dir):
     env = dict(os.environ)
-    env['GOPATH'] = GOPATH
+    env['GOPATH'] = gopath
     env['GOARCH'] = '386'
-    with WorkingDirectory(JUJU_CMD_DIR):
-        output = run(GO_CMD, 'build', env=env)
+    with WorkingDirectory(juju_cmd_dir):
+        output = run(go_cmd, 'build', env=env)
         print(output)
         print('Built Juju.exe')
-        shutil.move('juju.exe', ISS_DIR)
-        print('Moved {0} to {1}'.format('juju.exe', ISS_DIR))
-
-
-def package(version):
-    with WorkingDirectory(ISS_DIR):
-        output = run(ISS_CMD, 'setup.iss')
+        shutil.move('juju.exe', iss_dir)
+        print('Moved {0} to {1}'.format('juju.exe', iss_dir))
+
+
+def create_installer(version, iss_dir, iss_cmd, ci_dir):
+    with WorkingDirectory(iss_dir):
+        output = run(iss_cmd, 'setup.iss')
         print(output)
         installer_name = 'juju-setup-{0}.exe'.format(version)
-        installer_path = os.path.join(ISS_DIR, 'output', installer_name)
-        shutil.move(installer_path, CI_DIR)
-        print('Moved {0} to {1}'.format(installer_path, CI_DIR))
+        installer_path = os.path.join(iss_dir, 'output', installer_name)
+        shutil.move(installer_path, ci_dir)
+        print('Moved {0} to {1}'.format(installer_path, ci_dir))
     return installer_name
 
 
@@ -132,6 +139,24 @@
         raise Exception("Juju did not install")
 
 
+def build_agent(jujud_cmd_dir, go_cmd, gopath):
+    env = dict(os.environ)
+    env['GOPATH'] = gopath
+    env['GOARCH'] = 'amd64'
+    with WorkingDirectory(jujud_cmd_dir):
+        output = run(go_cmd, 'build', env=env)
+        print(output)
+        print('Built jujud.exe')
+
+
+def create_cloud_agent(version, jujud_cmd_dir, ci_dir):
+    tarball_name = 'juju-{}-win2012-amd64.tgz'.format(version)
+    tarball_path = os.path.join(ci_dir, tarball_name)
+    agent_path = os.path.join(jujud_cmd_dir, 'jujud.exe')
+    with tarfile.open(name=tarball_path, mode='w:gz') as tar:
+        tar.add(agent_path, arcname='jujud.exe')
+
+
 def main():
     if len(sys.argv) != 2:
         print('USAGE: {0} juju-core_X.X.X.tar.gz')
@@ -147,10 +172,12 @@
         setup(tarball_name)
         untar(tarball_path)
         move_source_to_gopath(tarball_name)
-        build()
-        installer_name = package(version)
+        build_client(JUJU_CMD_DIR, GO_CMD, GOPATH, ISS_DIR)
+        installer_name = create_installer(version, ISS_DIR, ISS_CMD, CI_DIR)
         install(installer_name)
         test(version)
+        build_agent(JUJUD_CMD_DIR, GO_CMD, GOPATH)
+        create_cloud_agent(version, JUJUD_CMD_DIR, CI_DIR)
         return 0
     except Exception as e:
         print(str(e))