vanagon 0.3.18

data/lib/vanagon/platform/osx.rb

@@ -0,0 +1,100 @@
+class Vanagon
+  class Platform
+    class OSX < Vanagon::Platform
+      # The specific bits used to generate a osx package for a given project
+      #
+      # @param project [Vanagon::Project] project to build a osx package of
+      # @return [Array] list of commands required to build a osx package for the given project from a tarball
+      def generate_package(project)
+        target_dir = project.repo ? output_dir(project.repo) : output_dir
+         # Setup build directories
+        ["bash -c 'mkdir -p $(tempdir)/osx/build/{dmg,pkg,scripts,resources,root,payload,plugins}'",
+         "mkdir -p $(tempdir)/osx/build/root/#{project.name}-#{project.version}",
+         # Grab distribution xml, scripts and other external resources
+         "cp #{project.name}-installer.xml $(tempdir)/osx/build/",
+         "cp scripts/* $(tempdir)/osx/build/scripts/",
+         "if [ -d resources/osx/productbuild ] ; then cp -r resources/osx/productbuild/* $(tempdir)/osx/build/; fi",
+         # Unpack the project
+         "gunzip -c #{project.name}-#{project.version}.tar.gz | '#{@tar}' -C '$(tempdir)/osx/build/root/#{project.name}-#{project.version}' --strip-components 1 -xf -",
+
+         # Move bill-of-materials into a docdir
+         "mkdir -p $(tempdir)/osx/build/root/#{project.name}-#{project.version}/usr/local/share/doc/#{project.name}",
+         "mv $(tempdir)/osx/build/root/#{project.name}-#{project.version}/bill-of-materials $(tempdir)/osx/build/root/#{project.name}-#{project.version}/usr/local/share/doc/#{project.name}/bill-of-materials",
+
+         # Package the project
+         "(cd $(tempdir)/osx/build/; #{@pkgbuild} --root root/#{project.name}-#{project.version} \
+          --scripts $(tempdir)/osx/build/scripts \
+          --identifier #{project.identifier}.#{project.name} \
+          --version #{project.version} \
+          --install-location / \
+          payload/#{project.name}-#{project.version}-#{project.release}.pkg)",
+         # Create a custom installer using the pkg above
+         "(cd $(tempdir)/osx/build/; #{@productbuild} --distribution #{project.name}-installer.xml \
+          --identifier #{project.identifier}.#{project.name}-installer \
+          --package-path payload/ \
+          --resources $(tempdir)/osx/build/resources  \
+          --plugins $(tempdir)/osx/build/plugins  \
+          pkg/#{project.name}-#{project.version}-#{project.release}-installer.pkg)",
+         # Create a dmg and ship it to the output dir
+         "(cd $(tempdir)/osx/build/; #{@hdiutil} create -volname #{project.name}-#{project.version} \
+          -srcfolder pkg/ dmg/#{project.package_name})",
+         "mkdir -p output/#{target_dir}",
+         "cp $(tempdir)/osx/build/dmg/#{project.package_name} ./output/#{target_dir}"]
+      end
+
+      # Method to generate the files required to build a osx package for the project
+      #
+      # @param workdir [String] working directory to stage the evaluated templates in
+      # @param name [String] name of the project
+      # @param binding [Binding] binding to use in evaluating the packaging templates
+      def generate_packaging_artifacts(workdir, name, binding)
+        resources_dir = File.join(workdir, "resources", "osx")
+        FileUtils.mkdir_p(resources_dir)
+        script_dir = File.join(workdir, "scripts")
+        FileUtils.mkdir_p(script_dir)
+
+        erb_file(File.join(VANAGON_ROOT, "templates/osx/project-installer.xml.erb"), File.join(workdir, "#{name}-installer.xml"), false, { :binding => binding })
+
+        ["postinstall", "preinstall"].each do |script_file|
+          erb_file(File.join(VANAGON_ROOT, "templates/osx/#{script_file}.erb"), File.join(script_dir, script_file), false, { :binding => binding })
+          FileUtils.chmod 0755, File.join(script_dir, script_file)
+        end
+
+        # Probably a better way to do this, but OSX tends to need some extra stuff
+        FileUtils.cp_r("resources/osx/.", resources_dir) if File.exist?("resources/osx/")
+      end
+
+      # Method to derive the package name for the project
+      #
+      # @param project [Vanagon::Project] project to name
+      # @return [String] name of the osx package for this project
+      def package_name(project)
+        "#{project.name}-#{project.version}-#{project.release}.#{@os_name}#{@os_version}.dmg"
+      end
+
+      # Get the expected output dir for the osx packages. This allows us to
+      # use some standard tools to ship internally.
+      #
+      # @return [String] relative path to where osx packages should be staged
+      def output_dir(target_repo = "")
+        File.join("apple", @os_version, target_repo, @architecture)
+      end
+
+      # Constructor. Sets up some defaults for the osx platform and calls the parent constructor
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::OSX] the osx derived platform with the given name
+      def initialize(name)
+        @name = name
+        @make = "/usr/bin/make"
+        @tar = "tar"
+        @pkgbuild = "/usr/bin/pkgbuild"
+        @productbuild = "/usr/bin/productbuild"
+        @hdiutil = "/usr/bin/hdiutil"
+        @patch = "/usr/bin/patch"
+        @num_cores = "/usr/sbin/sysctl -n hw.physicalcpu"
+        super(name)
+      end
+    end
+  end
+end

data/lib/vanagon/platform/rpm.rb

@@ -0,0 +1,76 @@
+require 'vanagon/utilities'
+include Vanagon::Utilities
+
+class Vanagon
+  class Platform
+    class RPM < Vanagon::Platform
+      # The specific bits used to generate an rpm package for a given project
+      #
+      # @param project [Vanagon::Project] project to build an rpm package of
+      # @return [Array] list of commands required to build an rpm package for the given project from a tarball
+      def generate_package(project)
+        target_dir = project.repo ? output_dir(project.repo) : output_dir
+        ["bash -c 'mkdir -p $(tempdir)/rpmbuild/{SOURCES,SPECS,BUILD,RPMS,SRPMS}'",
+        "cp #{project.name}-#{project.version}.tar.gz $(tempdir)/rpmbuild/SOURCES",
+        "cp file-list-for-rpm $(tempdir)/rpmbuild/SOURCES",
+        "cp #{project.name}.spec $(tempdir)/rpmbuild/SPECS",
+        "PATH=/opt/freeware/bin:$$PATH #{@rpmbuild} -bb --target #{@architecture} #{rpm_defines} $(tempdir)/rpmbuild/SPECS/#{project.name}.spec",
+        "mkdir -p output/#{target_dir}",
+        "cp $(tempdir)/rpmbuild/*RPMS/**/*.rpm ./output/#{target_dir}"]
+      end
+
+      # Method to generate the files required to build an rpm package for the project
+      #
+      # @param workdir [String] working directory to stage the evaluated templates in
+      # @param name [String] name of the project
+      # @param binding [Binding] binding to use in evaluating the packaging templates
+      def generate_packaging_artifacts(workdir, name, binding)
+        erb_file(File.join(VANAGON_ROOT, "templates/rpm/project.spec.erb"), File.join(workdir, "#{name}.spec"), false, { :binding => binding })
+      end
+
+      # Method to derive the package name for the project
+      #
+      # @param project [Vanagon::Project] project to name
+      # @return [String] name of the rpm package for this project
+      def package_name(project)
+        "#{project.name}-#{project.version}-#{project.release}.#{project.noarch ? 'noarch' : @architecture}.rpm"
+      end
+
+      # Get the expected output dir for the rpm packages. This allows us to
+      # use some standard tools to ship internally.
+      #
+      # @return [String] relative path to where rpm packages should be staged
+      def output_dir(target_repo = "products")
+        File.join(@os_name, @os_version, target_repo, @architecture)
+      end
+
+      def rpm_defines
+        defines =  %(--define '_topdir $(tempdir)/rpmbuild' )
+        # RPM doesn't allow dashes in the os_name. This was added to
+        # convert cisco-wrlinux to cisco_wrlinux
+        unless is_aix?
+          defines << %(--define 'dist .#{@os_name.gsub('-', '_')}#{@os_version}' )
+        end
+        defines
+      end
+
+      # Constructor. Sets up some defaults for the rpm platform and calls the parent constructor
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::RPM] the rpm derived platform with the given name
+      def initialize(name)
+        @name = name
+        @make = "/usr/bin/make"
+        @tar = "tar"
+        @patch = "/usr/bin/patch"
+        @num_cores = "/bin/grep -c 'processor' /proc/cpuinfo"
+        if is_aix?
+          @num_cores = "lsdev -Cc processor |wc -l"
+          @install = "/opt/freeware/bin/install"
+        end
+        @rpmbuild = "/usr/bin/rpmbuild"
+        super(name)
+      end
+    end
+  end
+end

data/lib/vanagon/platform/rpm/wrl.rb

@@ -0,0 +1,39 @@
+# This platform definition was created to account for oddities with
+# the RPM available on WindRiver Linux based systems. WRL uses RPMv5
+# and some of the WRL-based OS platforms we support (e.g, HuaweiOS)
+# do not have package repo systems or support for installing remote
+# RPMs via urls
+class Vanagon
+  class Platform
+    class RPM
+      class WRL < Vanagon::Platform::RPM
+        # Some WRL RPM platforms (e.g, HuaweiOS) don't allow you to
+        # install remote packages via url, so we'll do a dance to
+        # download them via curl and then perform the installs locally.
+        # This method generates a shell script to be executed on the
+        # system to do this.
+        #
+        # @param build_dependencies [Array] list of all build dependencies to install
+        # @return [String] a command to install all of the build dependencies
+        def install_build_dependencies(build_dependencies)
+          commands = []
+          unless build_dependencies.empty?
+            commands << "tmpdir=$(mktemp -p /var/tmp -d)"
+            commands << "cd ${tmpdir}"
+            build_dependencies.each do |build_dependency|
+              if build_dependency.match(/^http.*\.rpm$/)
+                # We're downloading each package individually so
+                # failures are easier to troubleshoot
+                commands << %(curl --remote-name --location --fail --silent #{build_dependency} && echo "Successfully downloaded #{build_dependency}")
+              end
+            end
+            # Install the downloaded packages
+            commands << "rpm -Uvh --nodeps --replacepkgs ${tmpdir}/*.rpm"
+          end
+
+          commands.join(' && ')
+        end
+      end
+    end
+  end
+end

data/lib/vanagon/platform/solaris_10.rb

@@ -0,0 +1,182 @@
+class Vanagon
+  class Platform
+    class Solaris10 < Vanagon::Platform
+      # The specific bits used to generate a solaris package for a given project
+      #
+      # @param project [Vanagon::Project] project to build a solaris package of
+      # @return [Array] list of commands required to build a solaris package for the given project from a tarball
+      def generate_package(project)
+        target_dir = project.repo ? output_dir(project.repo) : output_dir
+        name_and_version = "#{project.name}-#{project.version}"
+        pkg_name = package_name(project)
+
+        [
+          # Set up our needed directories
+          "mkdir -p $(tempdir)/#{name_and_version}",
+          "mkdir -p $(tempdir)/pkg",
+          "mkdir -p output/#{target_dir}",
+
+          # Unpack the project and stage the packaging artifacts
+          "gunzip -c #{name_and_version}.tar.gz | '#{@tar}' -C '$(tempdir)' -xf -",
+
+          # Move bill-of-materials into a docdir
+          "mkdir -p $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}",
+          "mv $(tempdir)/#{name_and_version}/bill-of-materials $(tempdir)/#{name_and_version}/usr/share/doc/#{project.name}/bill-of-materials",
+
+          "rm #{name_and_version}.tar.gz",
+          "cp -r packaging $(tempdir)/",
+
+          # Here we are tweaking file/dir ownership and perms in the following ways
+          # - All directories default to 0755 and root:sys
+          # - All files default to root:sys
+          # - The bin directory and all bin files are owned by root:bin instead of root:sys
+          # - All files under lib are owned by root:bin instead of root:sys
+          # - All .so files are owned by root:bin instead of root:sys
+          %((cd $(tempdir)/#{name_and_version}; pkgproto . | sort | awk ' \
+            $$1 ~ /^d$$/ {print "d",$$2,$$3,"0755 root sys";} \
+            $$1 ~ /^s$$/ {print;} \
+            $$1 ~ /^f$$/ {print "f",$$2,$$3,$$4,"root sys";} \
+            $$1 !~ /^[dfs]$$/ {print;} ' | /opt/csw/bin/gsed \
+               -e '/^[fd] [^ ]\\+ .*[/]s\\?bin/ {s/root sys$$/root bin/}' \
+               -e '/^[fd] [^ ]\\+ .*[/]lib[/][^/ ]\\+ / {s/root sys$$/root bin/}' \
+               -e '/^[fd] [^ ]\\+ .*[/][^ ]\\+[.]so / {s/root sys$$/root bin/}' >> ../packaging/proto) ),
+          %((cd $(tempdir); #{project.get_directories.map { |dir| "/opt/csw/bin/ggrep -q 'd none #{dir.path.sub(/^\//, '')}' packaging/proto || echo 'd none #{dir.path.sub(/^\//, '')} #{dir.mode || '0755'} #{dir.owner || 'root'} #{dir.group || 'sys'}' >> packaging/proto" }.join('; ')})),
+
+          # Actually build the package
+          "pkgmk -f $(tempdir)/packaging/proto -b $(tempdir)/#{name_and_version} -o -d $(tempdir)/pkg/",
+          "pkgtrans -s $(tempdir)/pkg/ $(tempdir)/pkg/#{pkg_name.gsub(/\.gz$/, '')} #{project.name}",
+          "gzip -c $(tempdir)/pkg/#{pkg_name.gsub(/\.gz$/, '')} > output/#{target_dir}/#{pkg_name}",
+        ]
+      end
+
+      # Method to generate the files required to build a solaris package for the project
+      #
+      # @param workdir [String] working directory to stage the evaluated templates in
+      # @param name [String] name of the project
+      # @param binding [Binding] binding to use in evaluating the packaging templates
+      def generate_packaging_artifacts(workdir, name, binding)
+        ["pkginfo", "depend", "preinstall", "preremove", "postinstall", "proto"].each do |template|
+          target_dir = File.join(workdir, 'packaging')
+          FileUtils.mkdir_p(target_dir)
+          erb_file(File.join(VANAGON_ROOT, "templates/solaris/10/#{template}.erb"), File.join(target_dir, template), false, { :binding => binding })
+        end
+      end
+
+      # Generate the scripts required to add a group to the package generated.
+      # This will also update the group if it has changed.
+      #
+      # @param user [Vanagon::Common::User] the user to reference for the group
+      # @return [String] the commands required to add a group to the system
+      def add_group(user)
+        # NB: system users aren't supported on solaris 10
+        return <<-HERE.undent
+          if ! getent group '#{user.group}' > /dev/null 2>&1; then
+            /usr/sbin/groupadd '#{user.group}'
+          fi
+        HERE
+      end
+
+      # Generate the scripts required to add a user to the package generated.
+      # This will also update the user if it has changed.
+      #
+      # @param user [Vanagon::Common::User] the user to create
+      # @return [String] the commands required to add a user to the system
+      def add_user(user)
+        # NB: system users aren't supported on solaris 10
+        # Solaris 10 also doesn't support long flags
+        cmd_args = ["'#{user.name}'"]
+        cmd_args.unshift "-g '#{user.group}'" if user.group
+        cmd_args.unshift "-d '#{user.homedir}'" if user.homedir
+        if user.shell
+          cmd_args.unshift "-s '#{user.shell}'"
+        elsif user.is_system
+          # Even though system users aren't a thing, we can still disable the shell
+          cmd_args.unshift "-s '/usr/bin/false'"
+        end
+
+        user_args = cmd_args.join("\s")
+
+        return <<-HERE.undent
+          if getent passwd '#{user.name}' > /dev/null 2>&1; then
+            /usr/sbin/usermod #{user_args}
+          else
+            /usr/sbin/useradd #{user_args}
+          fi
+        HERE
+      end
+
+      # Method to derive the package name for the project
+      #
+      # @param project [Vanagon::Project] project to name
+      # @return [String] name of the solaris package for this project
+      def package_name(project)
+        "#{project.name}-#{project.version}-#{project.release}.#{@architecture}.pkg.gz"
+      end
+
+      # Get the expected output dir for the solaris 10 packages. This allows us to
+      # use some standard tools to ship internally.
+      #
+      # @return [String] relative path to where solaris 10 packages should be staged
+      def output_dir(target_repo = "")
+        File.join("solaris", @os_version, target_repo)
+      end
+
+      # Because solaris has multiple terrible ways to install packages, we have
+      # this method which generates a shell script to be executed on the system
+      # which will install all of the build dependencies
+      #
+      # @param build_dependencies [Array] list of all build dependencies to install
+      # @return [String] a command to install all of the build dependencies
+      def install_build_dependencies(build_dependencies)
+        http = []
+        pkgutil = []
+        noasks = ["instance=overwrite", "partial=nocheck", "runlevel=nocheck", "idepend=nocheck", "rdepend=nocheck", "space=nocheck", "setuid=nocheck", "conflict=nocheck", "action=nocheck", "basedir=default"]
+        noask_command = noasks.map { |noask| "echo '#{noask}' >> /var/tmp/noask" }.join('; ')
+
+        build_dependencies.each do |build_dependency|
+          if build_dependency.match(/^http.*\.gz/)
+            # Fetch, unpack, install...this assumes curl is present.
+            package = build_dependency.sub(/^http.*\//, '')
+            http << "tmpdir=$(mktemp -p /var/tmp -d); (cd ${tmpdir} && curl -O #{build_dependency} && gunzip -c #{package} | pkgadd -d /dev/stdin -a /var/tmp/noask all)"
+          else
+            # Opencsw dependencies. At this point we assume that pkgutil is installed.
+            pkgutil << build_dependency
+          end
+        end
+
+        command = ''
+        unless pkgutil.empty?
+          command << "/opt/csw/bin/pkgutil -y -i #{pkgutil.join("\s")}; "
+        end
+
+        unless http.empty?
+          command << "echo -n > /var/tmp/noask; #{noask_command}; "
+          command << http.join('; ')
+        end
+
+        command
+      end
+
+      # Constructor. Sets up some defaults for the solaris 10 platform and calls the parent constructor
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::Solaris] the solaris 10 derived platform with the given name
+      def initialize(name)
+        @name = name
+        @make = "/opt/csw/bin/gmake"
+        @tar = "/usr/sfw/bin/gtar"
+        @patch = "/usr/bin/gpatch"
+        # solaris 10
+        @num_cores = "/usr/bin/kstat cpu_info | awk '{print $$1}' | grep '^core_id$$' | wc -l"
+        super(name)
+        if @architecture == "sparc"
+          @platform_triple = "sparc-sun-solaris2.#{@os_version}"
+        elsif @architecture == "i386"
+          @platform_triple = "i386-pc-solaris2.#{@os_version}"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vanagon/platform/solaris_11.rb

@@ -0,0 +1,138 @@
+class Vanagon
+  class Platform
+    class Solaris11 < Vanagon::Platform
+      # The specific bits used to generate a solaris package for a given project
+      #
+      # @param project [Vanagon::Project] project to build a solaris package of
+      # @return [Array] list of commands required to build a solaris package for the given project from a tarball
+      def generate_package(project)
+        target_dir = project.repo ? output_dir(project.repo) : output_dir
+        name_and_version = "#{project.name}-#{project.version}"
+        pkg_name = package_name(project)
+
+        [
+          # Set up our needed directories
+          "mkdir -p $(tempdir)/#{name_and_version}",
+          "mkdir -p $(tempdir)/pkg",
+          "mkdir -p output/#{target_dir}",
+
+          # Unpack the project and stage the packaging artifacts
+          "gunzip -c #{name_and_version}.tar.gz | '#{@tar}' -C '$(tempdir)' -xf -",
+          "cp -r packaging $(tempdir)/",
+          "pkgrepo create $(tempdir)/repo",
+          "pkgrepo set -s $(tempdir)/repo publisher/prefix=#{project.identifier}",
+
+          "(cd $(tempdir); pkgsend generate #{name_and_version} | pkgfmt >> packaging/#{project.name}.p5m.1)",
+
+          # Actually build the package
+          "(cd $(tempdir)/packaging; pkgmogrify -DARCH=`uname -p` #{project.name}.p5m.1 #{project.name}.p5m | pkgfmt > #{project.name}.p5m.2)",
+          "pkglint $(tempdir)/packaging/#{project.name}.p5m.2",
+          "pkgsend -s 'file://$(tempdir)/repo' publish -d '$(tempdir)/#{name_and_version}' --fmri-in-manifest '$(tempdir)/packaging/#{project.name}.p5m.2'",
+          "pkgrecv -s 'file://$(tempdir)/repo' -a -d 'output/#{target_dir}/#{pkg_name}' '#{project.name}@#{ips_version(project.version, project.release)}'",
+
+          # Now make sure the package we built isn't totally broken (but not when cross-compiling)
+          %(if [ "#{@architecture}" = `uname -p` ]; then pkg install -nv -g 'output/#{target_dir}/#{pkg_name}' '#{project.name}@#{ips_version(project.version, project.release)}'; fi),
+        ]
+      end
+
+      # Method to generate the files required to build a solaris package for the project
+      #
+      # @param workdir [String] working directory to stage the evaluated templates in
+      # @param name [String] name of the project
+      # @param binding [Binding] binding to use in evaluating the packaging templates
+      def generate_packaging_artifacts(workdir, name, binding)
+        target_dir = File.join(workdir, 'packaging')
+        FileUtils.mkdir_p(target_dir)
+        erb_file(File.join(VANAGON_ROOT, "templates/solaris/11/p5m.erb"), File.join(target_dir, "#{name}.p5m"), false, { :binding => binding })
+      end
+
+      # Generate the scripts required to add a group to the package generated.
+      # This will also update the group if it has changed.
+      #
+      # @param user [Vanagon::Common::User] the user to reference for the group
+      # @return [String] the commands required to add a group to the system
+      def add_group(user)
+        "group groupname=#{user.group}"
+      end
+
+      # Helper to setup an IPS build repo on a target system
+      # http://docs.oracle.com/cd/E36784_01/html/E36802/gkkek.html
+      #
+      # @param uri [String] uri of the repository to add
+      # @param origin [String] origin of the repository
+      # @return [String] the command required to add an ips build repository
+      def add_repository(uri, origin)
+        "pkg set-publisher -G '*' -g #{uri} #{origin}"
+      end
+
+      # Generate the scripts required to add a user to the package generated.
+      # This will also update the user if it has changed.
+      #
+      # @param user [Vanagon::Common::User] the user to create
+      # @return [String] the commands required to add a user to the system
+      def add_user(user)
+        command = "user username=#{user.name}"
+        command << " group=#{user.group}" if user.group
+        command << " home-dir=#{user.homedir}" if user.homedir
+        if user.shell
+          command << " login-shell=#{user.shell}"
+        elsif user.is_system
+          command << " login-shell=/usr/bin/false"
+        end
+
+        command
+      end
+
+      # Method to derive the package name for the project
+      #
+      # @param project [Vanagon::Project] project to name
+      # @return [String] name of the solaris package for this project
+      def package_name(project)
+        "#{project.name}@#{ips_version(project.version, project.release)}.#{@architecture}.p5p"
+      end
+
+      # Method to transform a standard version into the format expected by IPS
+      # packages
+      #
+      # @param version [String] Standard package version
+      # @param release [String] Standard package release
+      # @return [String] version in IPS format
+      def ips_version(version, release)
+        version.gsub!(/[a-zA-Z]/, '')
+        version.gsub!(/(^-)|(-$)/, '')
+
+        # Here we strip leading 0 from version components but leave singular 0 on their own.
+        version = version.split('.').map(&:to_i).join('.')
+        "#{version},5.11-#{release}"
+      end
+
+      # Get the expected output dir for the solaris 11 packages. This allows us to
+      # use some standard tools to ship internally.
+      #
+      # @return [String] relative path to where solaris 11 packages should be staged
+      def output_dir(target_repo = "")
+        File.join("solaris", @os_version, target_repo)
+      end
+
+      # Constructor. Sets up some defaults for the solaris 11 platform and calls the parent constructor
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::Solaris] the solaris 11 derived platform with the given name
+      def initialize(name)
+        @name = name
+        @make = "/usr/bin/gmake"
+        @tar = "/usr/bin/gtar"
+        @patch = "/usr/bin/gpatch"
+        @num_cores = "/usr/bin/kstat cpu_info | /usr/bin/ggrep -E '[[:space:]]+core_id[[:space:]]' | wc -l"
+        super(name)
+        if @architecture == "sparc"
+          @platform_triple = "sparc-sun-solaris2.#{@os_version}"
+        elsif @architecture == "i386"
+          @platform_triple = "i386-pc-solaris2.#{@os_version}"
+        end
+      end
+    end
+  end
+end
+
+