Revert "Merge remote branch 'cros/upstream' into tempbranch2"

server/git_kernel.py

+#
+# Copyright 2007 IBM Corp. Released under the GPL v2
+# Authors: Ryan Harper <ryanh@us.ibm.com>
+#
+
 """
 This module defines the GitKernel class
-
-@author: Ryan Harper (ryanh@us.ibm.com)
-@copyright: IBM 2007
 """
 
-import os, logging
+__author__ = """
+ryanh@us.ibm.com (Ryan Harper)
+"""
+
+
+import os
 import git, source_kernel
 
 
-class GitKernel(git.InstallableGitRepo):
+class GitKernel(git.GitRepo):
     """
-    This class represents an installable git kernel repo.
+    This class represents a git kernel repo.
 
     It is used to pull down a local copy of a git repo, check if the local repo
     is up-to-date, if not update and then build the kernel from the git repo.
+
     """
     def __init__(self, repodir, giturl, weburl):
-        super(GitKernel, self).__init__(repodir, giturl, weburl)
-        self._patches = []
-        self._config = None
-        self._build = None
-        self._branch = None
-        self._revision = None
+        git.GitRepo.__init__(self, repodir, giturl, weburl)
+        self.__patches = []
+        self.__config = None
+        self.__build = None
 
 
     def configure(self, config):
-        self._config = config
+        self.__config = config
 
 
     def patch(self, patch):
-        self._patches.append(patch)
+        self.__patches.append(patch)
 
 
-    def checkout(self, revision, local=None):
-        """
-        Checkout the commit id, branch, or tag.
-
-        @param revision: Name of the git remote branch, revision or tag
-        @param local: Name of the local branch, implies -b
-        """
-        logging.info('Checking out %s', revision)
-        super(GitKernel, self).checkout(revision)
-        self._revision = super(GitKernel, self).get_revision()
-        self._branch = super(GitKernel, self).get_branch()
-        logging.info('Checked out %s on branch %s', self._revision,
-                     self._branch)
-
-
-    def show_branch(self):
-        """
-        Print the current local branch name.
-        """
-        self._branch = super(GitKernel, self).get_branch()
-        logging.info(self._branch)
-
-
-    def show_branches(self, all=True):
-        """
-        Print the local and remote branches.
-
-        @param all: Whether to show all branches (True) or only local branches
-                (False).
-        """
-        self._branch = super(GitKernel, self).get_branch()
-        logging.info(super(GitKernel, self).get_branch(all=all))
-
-
-    def show_revision(self):
-        """
-        Show the current git revision.
-        """
-        self._revision = super(GitKernel, self).get_revision()
-        logging.info(self._revision)
-
-
-    def install(self, host, build=True, builddir=None, revision=None):
-        """
-        Install the git tree in a host.
-
-        @param host: Host object
-        @param build: Whether to build the source tree
-        @param builddir: Specify a build dir. If no build dir is specified,
-                the job temporary directory will be used, so the build won't
-                be persistent.
-        @param revision: Desired commit hash. If ommited, will build from HEAD
-                of the branch.
-        """
-        if revision:
-            self.checkout(revision)
-            self._revision = super(GitKernel, self).get_revision()
-            logging.info('Checked out revision: %s', self._revision)
-
+    def install(self, host, build=True, builddir=None):
+        # use tmpdir if no builddir specified
+        # NB: pass a builddir to install() method if you
+        # need to ensure the build remains after the completion
+        # of a job
         if not builddir:
-            self._build = os.path.join(host.get_tmp_dir(), "build")
-            logging.warning('Builddir %s is not persistent (it will be erased '
-                            'in future jobs)', self._build)
+            self.__build = os.path.join(host.get_tmp_dir(),"build")
+            print 'warning: builddir %s is not persistent' %(self.__build)
 
         # push source to host for install
-        logging.info('Pushing %s to host', self.source_material)
-        host.send_file(self.source_material, self._build)
+        print 'pushing %s to host' %(self.source_material)
+        host.send_file(self.source_material, self.__build)
+        remote_source_material= os.path.join(self.__build,
+                        os.path.basename(self.source_material))
 
         # use a source_kernel to configure, patch, build and install.
-        sk = source_kernel.SourceKernel(self._build)
+        sk = source_kernel.SourceKernel(remote_source_material)
 
         if build:
             # apply patches
-            for p in self._patches:
+            for p in self.__patches:
                 sk.patch(p)
 
             # configure
-            sk.configure(self._config)
+            sk.configure(self.__config)
 
             # build
             sk.build(host)
 
         # install
         sk.install(host)