Massive increase of changes. Too many to count

4 files changed, 185 insertions, 28 deletions

diff --git a/ipsbuild-setuptree.py b/ipsbuild-setuptree.py
index 135c4e9..0ad38a8 100644
--- a/ipsbuild-setuptree.py
+++ b/ipsbuild-setuptree.py
@@ -1,14 +1,15 @@
 import os
 import sys
 
+home = None
 try:
-    if sys.platform == 'linux' or sys.platform == 'darwin':
+    if sys.platform == 'linux2' or sys.platform == 'darwin':
         home = os.path.normpath(os.environ['HOME'])
     elif sys.platform == 'win32':
         home = os.path.normpath(os.environ['USERPROFILE'])
 except:
     Exception("Unsupported platform: {0:s}".format(sys.platform))
-    
+
 head = os.path.join(home, 'ipsbuild')
 tree = ['BUILDROOT',
         'BUILD',
@@ -22,14 +23,14 @@ def create_dir(dirent):
     os.mkdir(dirent)
 
 def main():
-    try:
-        self.create_dir(head)
-    except:
-        print("{0:s} already exists, please remove it.".format(head))
-    
+#    try:
+    create_dir(head)
+#    except:
+#        print("{0:s} already exists, please remove it.".format(head))
+
     try:
         for d in tree:
-            self.create_dir(os.path.join(head, d))
+            create_dir(os.path.join(head, d))
     except:
         pass
 
diff --git a/ipsbuild.py b/ipsbuild.py
index af53bdb..dd9d26f 100644
--- a/ipsbuild.py
+++ b/ipsbuild.py
@@ -2,23 +2,54 @@
 # Automate package creation
 
 from pprint import pprint
-from collections import deque
 import subprocess
 import shlex
-import ConfigParser
 import argparse
 import string
+import sys
+import os
+
+class IPS_Environment(object):
+    def __init__(self):
+        super(IPS_Environment, self).__init__()
+        self._basepath = os.path.join(os.environ['HOME'], 'ipsbuild')
+        self.env = {
+                'BUILDROOT': self.pathgen('BUILDROOT'),
+                'BUILD': self.pathgen('BUILD'),
+                'SPECS': self.pathgen('SPECS'),
+                'SOURCES': self.pathgen('SOURCES'),
+                'PKGS': self.pathgen('PKGS'),
+                'SPKGS': self.pathgen('SPKGS')
+                }
+
+        self.tool = {
+                    'tar': 'tar',
+                    'unzip': 'unzip',
+                    'gunzip': 'gunzip',
+                    'bunzip': 'bunzip'
+                    }
+
+        if sys.platform == 'solaris':
+            self.tool['tar'] = 'gtar'
+
+
+    def pathgen(self, path):
+        return os.path.join(self._basepath, path)
 
 class IPS_Config(object):
     def __init__(self, ipsfile):
-
+        super(IPS_Config, self).__init__()
         key_dict = {
                 'name': '',
                 'version': '',
                 'release': '',
                 'maintainer': '',
+                'group': '',
                 'upstream_url': '',
+                'source_url': '',
                 'description': '',
+                'summary': '',
+                'classification': '',
                 'arch': '',
                 'license': ''
                 }
@@ -37,7 +68,7 @@ class IPS_Config(object):
                     key_dict[key] = parts[1]
 
         found_data = False
-        code_section = ['%build', '%prep', '%install', '%files']
+        code_section = ['%build', '%prep', '%install']
         for section in code_section:
             for line in file(ipsfile).readlines():
                 parts = shlex.split(line)
@@ -52,21 +83,132 @@ class IPS_Config(object):
         self.key_dict = key_dict
         self.script_dict = script_dict
 
-class IPS_Task(object):
-    def __init__(self, task):
-        if type(task) is not type(list):
+
+class IPS_TaskController(list):
+    def __init__(self):
+        super(IPS_TaskController, self).__init__()
+        self._store = []
+
+    def task(self, task):
+        super(IPS_TaskController, self).append(task)
+
+    def do_tasks(self):
+        for task in super(IPS_TaskController, self).__iter__():
+            self._store.append(task.run())
+
+class IPS_NamedTask(object):
+    def __init__(self, name, task_list):
+        if type(task_list) is not type(list):
             TypeError("task must be a list")
 
-class IPS_Build(IPS_Config):
+        self.name = name
+        self.task = task_list
+
+    def run(self):
+        print("Running task: {0:s}".format(self.name))
+        for step in self.task:
+            print("+ {0:s}".format(step))
+
+class IPS_Build(IPS_Config, IPS_Environment):
     def __init__(self, ipsfile):
+        # Parent IPS_Config parses configuration data in .ips file
+        # Inherited members are used to populate package information
+        # as well as build tasks
         super(IPS_Build, self).__init__(ipsfile)
-        self.task_queue = deque()
-        for key in self.script_dict:
-            for i in self.script_dict[key]:
-                self.task_queue.append(IPS_Task(i))
-        
+        # Um, super and multiple inheritance SUCKS... back to Python2 style
+        #IPS_Environment.__init__(self)
+
+        # Create list of build tasks
+        ordered_tasks = ['prep', 'build', 'install']
+        self.controller = IPS_TaskController()
+
+        # Assign built-in IPS tasks
+        self.controller.task(IPS_NamedTask('Extract source', self.source_unpack()))
+        self.controller.task(IPS_NamedTask('Create buildroot', self.create_buildroot()))
+        self.controller.task(IPS_NamedTask('Create metadata', self.create_metadata()))
+
+        # Assign user defined .ips tasks in build order
+        for user_task in ordered_tasks:
+            self.controller.task(IPS_NamedTask(user_task, self.script_dict[user_task]))
+
+
+    def source_unpack(self):
+        path = os.path.join(self.env['SOURCES'],
+                            os.path.basename(self.key_dict['source_url']))
+        ext = {
+               '.tar': '{0:s} xf {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.gz': '{0:s} xfz {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.bz2': '{0:s} xfj {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.tar.xz': '{0:s} xfJ {1:s} -C {2:s}'.format(self.tool['tar'], path, self.env['BUILD']),
+               '.gz': self.tool['gunzip'],
+               '.bz2': self.tool['bunzip'],
+               '.zip': self.tool['unzip']
+        }
+        cmd = []
+        for k, v in ext.items():
+            if k in path:
+                cmd = v.split()
+                subprocess.check_output(cmd)
+                break
+        return [cmd]
+
+    def create_buildroot(self):
+        path = os.path.join(self.env['BUILDROOT'],
+                            self.key_dict['name'] +
+                            "-" +
+                            self.key_dict['version'])
+        if os.path.exists(path):
+            os.remove(path)
+        os.mkdir(path)
+        return [path]
+
+    def create_metadata(self):
+        output = []
+        meta_map = {
+                     'pkg.fmri': self.key_dict['name'],
+                     'pkg.description': self.key_dict['description'],
+                     'pkg.summary': self.key_dict['summary'],
+                     'variant.arch': self.key_dict['arch'],
+                     'info.upstream_url': self.key_dict['upstream_url'],
+                     'info.source_url': self.key_dict['source_url'],
+                     'info.classification': self.key_dict['classification']
+                     }
+        template = file('metadata.tpl', 'r')
+        for line in template.readlines():
+            for k, v in meta_map.items():
+                if k in line:
+                    # pkg.fmri requires special attention to build the proper
+                    # package name IPS wants
+                    if k == 'pkg.fmri':
+                        output.append(line.replace('{}',
+                           self.key_dict['group'] +
+                           "/" +
+                           self.key_dict['name'] +
+                           "@" +
+                           self.key_dict['version'] +
+                           "," +
+                           self.key_dict['release']
+                           ).strip('\n'))
+                        continue
+                    # The rest of the value replacements are rather simple
+                    output.append(line.replace('{}', v).strip('\n'))
+        return output
+
+    def create_package_list(self):
+        pass
+
+
+    def show_summary(self):
+        print("Summary of {0:s}".format(self.key_dict['name']))
+        for k, v in sorted(self.key_dict.items()):
+            print("+ {0:s}: {1:s}".format(k, v))
+
+
 
 
 testfile = "test.ips"
 build = IPS_Build(testfile)
-print build.task_queue
+#build.show_summary()
+build.controller.do_tasks()
+#build.source_unpack()
+
diff --git a/metadata.tpl b/metadata.tpl
new file mode 100644
index 0000000..573fee3
--- /dev/null
+++ b/metadata.tpl
@@ -0,0 +1,7 @@
+set name=pkg.fmri value={}
+set name=pkg.description value="{}"
+set name=pkg.summary value="{}"
+set name=variant.arch value={}
+set name=info.upstream_url value="{}"
+set name=info.source-url value="{}"
+set name=info.classification value="{}"
diff --git a/test.ips b/test.ips
index b13446e..45a95e8 100644
--- a/test.ips
+++ b/test.ips
@@ -1,12 +1,19 @@
-name:          developer/testpkg
-version:       0.1
-release:       1
-maintainer:    test person
-upstream_url:  http://localhost/testpkg.tar.gz
-description:   a test package
+name:           testpkg
+version:        0.1
+release:        1
+maintainer:     test person
+upstream_url:   http://localhost/testpkg-0.1.tar.gz
+source_url:     http://localhost/testpkg-0.1.tar.gz
+description:    "a test package"
+summary:        "test package"
+group:          developer
+classification: "edu.stsci:Development/Solaris 11"
 arch:          i386
 license:       GPL
 
+%setup
+%end
+
 %prep
 %end