vanagon 0.3.18

data/lib/vanagon/platform.rb

@@ -0,0 +1,245 @@
+require 'vanagon/platform/dsl'
+
+class Vanagon
+  class Platform
+    attr_accessor :make, :servicedir, :defaultdir, :provisioning, :num_cores, :tar
+    attr_accessor :build_dependencies, :name, :vmpooler_template, :cflags, :ldflags, :settings
+    attr_accessor :servicetype, :patch, :architecture, :codename, :os_name, :os_version
+    attr_accessor :docker_image, :ssh_port, :rpmbuild, :install, :platform_triple
+
+    # Platform names currently contain some information about the platform. Fields
+    # within the name are delimited by the '-' character, and this regex can be used to
+    # extract those fields.
+    PLATFORM_REGEX = /^(.*)-(.*)-(.*)$/
+
+    # Loads a given platform from the configdir
+    #
+    # @param name [String] the name of the platform
+    # @param configdir [String] the path to the platform config file
+    # @return [Vanagon::Platform] the platform as specified in the platform config
+    # @raise if the instance_eval on Platform fails, the exception is reraised
+    def self.load_platform(name, configdir)
+      platfile = File.join(configdir, "#{name}.rb")
+      code = File.read(platfile)
+      dsl = Vanagon::Platform::DSL.new(name)
+      dsl.instance_eval(code, __FILE__, __LINE__)
+      dsl._platform
+    rescue => e
+      puts "Error loading platform '#{name}' using '#{platfile}':"
+      puts e
+      puts e.backtrace.join("\n")
+      raise e
+    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)
+      cmd_args = ["'#{user.group}'"]
+      cmd_args.unshift '--system' if user.is_system
+
+      groupadd_args = cmd_args.join "\s"
+      groupmod_args = (cmd_args - ["--system"]).join "\s"
+
+      return <<-HERE.undent
+        if getent group '#{user.group}' > /dev/null 2>&1; then
+          /usr/sbin/groupmod #{groupmod_args}
+        else
+          /usr/sbin/groupadd #{groupadd_args}
+        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)
+      cmd_args = ["'#{user.name}'"]
+      cmd_args.unshift "--home '#{user.homedir}'" if user.homedir
+      if user.shell
+        cmd_args.unshift "--shell '#{user.shell}'"
+      elsif user.is_system
+        cmd_args.unshift "--shell '/usr/sbin/nologin'"
+      end
+      cmd_args.unshift "--gid '#{user.group}'" if user.group
+      cmd_args.unshift '--system' if user.is_system
+
+      # Collapse the cmd_args array into a string that can be used
+      # as an argument to `useradd`
+      useradd_args = cmd_args.join "\s"
+
+      # Collapse the cmd_args array into a string that can be used
+      # as an argument to `usermod`; If this is a system account,
+      # then specify it as such for user addition only (strip
+      # --system from usermod_args)
+      usermod_args = (cmd_args - ["--system"]).join "\s"
+
+      return <<-HERE.undent
+        if getent passwd '#{user.name}' > /dev/null 2>&1; then
+          /usr/sbin/usermod #{useradd_args}
+        else
+          /usr/sbin/useradd #{usermod_args}
+        fi
+      HERE
+    end
+
+    # Platform constructor. Takes just the name. Also sets the @name, @os_name,
+    # \@os_version and @architecture instance attributes as a side effect
+    #
+    # @param name [String] name of the platform
+    # @return [Vanagon::Platform] the platform with the given name
+    def initialize(name)
+      @name = name
+      @os_name = os_name
+      @os_version = os_version
+      @architecture = architecture
+      @ssh_port = 22
+      @provisioning = []
+      @install ||= "install"
+    end
+
+    # This allows instance variables to be accessed using the hash lookup syntax
+    def [](key)
+      if instance_variable_get("@#{key}")
+        instance_variable_get("@#{key}")
+      end
+    end
+
+    # Sets and gets the name of the operating system for the platform.
+    # Also has the side effect of setting the @os_name instance attribute
+    #
+    # @return [String] the operating system name as specified in the platform
+    def os_name
+      @os_name ||= @name.match(PLATFORM_REGEX)[1]
+    end
+
+    # Sets and gets the version of the operating system for the platform.
+    # Also has the side effect of setting the @os_version instance attribute
+    #
+    # @return [String] the operating system version as specified in the platform
+    def os_version
+      @os_version ||= @name.match(PLATFORM_REGEX)[2]
+    end
+
+    # Sets and gets the architecture of the platform.
+    # Also has the side effect of setting the @architecture instance attribute
+    #
+    # @return [String] the architecture of the platform
+    def architecture
+      @architecture ||= @name.match(PLATFORM_REGEX)[3]
+    end
+
+    # Utility matcher to determine is the platform is a debian variety
+    #
+    # @return [true, false] true if it is a debian variety, false otherwise
+    def is_deb?
+      return !!@name.match(/^(debian|ubuntu|cumulus)-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a redhat variety or
+    # uses rpm under the hood
+    #
+    # @return [true, false] true if it is a redhat variety or uses rpm
+    # under the hood, false otherwise
+    def is_rpm?
+      return !!@name.match(/^(aix|cisco-wrlinux|el|eos|fedora|huaweios|nxos|sles)-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is an enterprise linux variety
+    #
+    # @return [true, false] true if it is a enterprise linux variety, false otherwise
+    def is_el?
+      return !!@name.match(/^el-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a sles variety
+    #
+    # @return [true, false] true if it is a sles variety, false otherwise
+    def is_sles?
+      return !!@name.match(/^sles-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a fedora variety
+    #
+    # @return [true, false] true if it is a fedora variety, false otherwise
+    def is_fedora?
+      return !!@name.match(/^fedora-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is an aix variety
+    #
+    # @return [true, false] true if it is an aix variety, false otherwise
+    def is_aix?
+      return !!@name.match(/^aix-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is an eos variety
+    #
+    # @return [true, false] true if it is an eos variety, false otherwise
+    def is_eos?
+      return !!@name.match(/^eos-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a HuaweiOS variety
+    #
+    # @return [true, false] true if it is a HuaweiOS variety, false otherwise
+    def is_huaweios?
+      return !!@name.match(/^huaweios-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is an nxos variety
+    #
+    # @return [true, false] true if it is an nxos variety, false otherwise
+    def is_nxos?
+      return !!@name.match(/^nxos-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a cisco-wrlinux
+    # variety
+    #
+    # @return [true, false] true if it is a cisco-wrlinux variety, false
+    # otherwise
+    def is_cisco_wrlinux?
+      return !!@name.match(/^cisco-wrlinux-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is an osx variety
+    #
+    # @return [true, false] true if it is an osx variety, false otherwise
+    def is_osx?
+      return !!@name.match(/^osx-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a solaris variety
+    #
+    # @return [true, false] true if it is an solaris variety, false otherwise
+    def is_solaris?
+      return !!@name.match(/^solaris-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a unix variety
+    #
+    # @return [true, false] true if it is a unix variety, false otherwise
+    def is_unix?
+      return !!@name.match(/^(solaris|aix|osx)-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a windows variety
+    #
+    # @return [true, false] true if it is a windows variety, false otherwise
+    def is_windows?
+      return !!@name.match(/^win-.*$/)
+    end
+
+    # Utility matcher to determine is the platform is a linux variety
+    #
+    # @return [true, false] true if it is a linux variety, false otherwise
+    def is_linux?
+      return (!is_windows? && !is_unix?)
+    end
+  end
+end

data/lib/vanagon/platform/deb.rb

@@ -0,0 +1,71 @@
+class Vanagon
+  class Platform
+    class DEB < Vanagon::Platform
+      # The specific bits used to generate a debian package for a given project
+      #
+      # @param project [Vanagon::Project] project to build a debian package of
+      # @return [Array] list of commands required to build a debian package for the given project from a tarball
+      def generate_package(project)
+        target_dir = project.repo ? output_dir(project.repo) : output_dir
+        ["mkdir -p output/#{target_dir}",
+        "mkdir -p $(tempdir)/#{project.name}-#{project.version}",
+        "cp #{project.name}-#{project.version}.tar.gz $(tempdir)/#{project.name}_#{project.version}.orig.tar.gz",
+        "cat file-list >> debian/install",
+        "cp -pr debian $(tempdir)/#{project.name}-#{project.version}",
+        "gunzip -c #{project.name}-#{project.version}.tar.gz | '#{@tar}' -C '$(tempdir)/#{project.name}-#{project.version}' --strip-components 1 -xf -",
+        "sed -i 's/\ /?/g' $(tempdir)/#{project.name}-#{project.version}/debian/install",
+        "(cd $(tempdir)/#{project.name}-#{project.version}; debuild --no-lintian -uc -us)",
+        "cp $(tempdir)/*.deb ./output/#{target_dir}"]
+      end
+
+      # Method to generate the files required to build a debian 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)
+        deb_dir = File.join(workdir, "debian")
+        FileUtils.mkdir_p(deb_dir)
+
+        # Lots of templates here
+        ["changelog", "conffiles", "control", "docs", "dirs", "install", "postinst", "postrm", "prerm", "rules"].each do |deb_file|
+          erb_file(File.join(VANAGON_ROOT, "templates/deb/#{deb_file}.erb"), File.join(deb_dir, deb_file), false, { :binding => binding })
+        end
+
+        # These could be templates, but their content is static, so that seems weird.
+        File.open(File.join(deb_dir, "compat"), "w") { |f| f.puts("7") }
+        FileUtils.mkdir_p(File.join(deb_dir, "source"))
+        File.open(File.join(deb_dir, "source", "format"), "w") { |f| f.puts("3.0 (quilt)") }
+      end
+
+      # Method to derive the package name for the project
+      #
+      # @param project [Vanagon::Project] project to name
+      # @return [String] name of the debian package for this project
+      def package_name(project)
+        "#{project.name}_#{project.version}-#{project.release}#{@codename}_#{project.noarch ? 'all' : @architecture}.deb"
+      end
+
+      # Get the expected output dir for the debian packages. This allows us to
+      # use some standard tools to ship internally.
+      #
+      # @return [String] relative path to where debian packages should be staged
+      def output_dir(target_repo = "")
+        File.join("deb", @codename, target_repo)
+      end
+
+      # Constructor. Sets up some defaults for the debian platform and calls the parent constructor
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::DEB] the deb derived platform with the given name
+      def initialize(name)
+        @name = name
+        @make = "/usr/bin/make"
+        @tar = "tar"
+        @patch = "/usr/bin/patch"
+        @num_cores = "/usr/bin/nproc"
+        super(name)
+      end
+    end
+  end
+end

data/lib/vanagon/platform/dsl.rb

@@ -0,0 +1,293 @@
+require 'vanagon/platform/deb'
+require 'vanagon/platform/rpm'
+require 'vanagon/platform/rpm/wrl'
+require 'vanagon/platform/swix'
+require 'vanagon/platform/osx'
+require 'vanagon/platform/solaris_10'
+require 'vanagon/platform/solaris_11'
+require 'securerandom'
+require 'uri'
+
+class Vanagon
+  class Platform
+    class DSL
+      # Constructor for the DSL object
+      #
+      # @param name [String] name of the platform
+      # @return [Vanagon::Platform::DSL] A DSL object to describe the {Vanagon::Platform}
+      def initialize(name)
+        @name = name
+      end
+
+      # Primary way of interacting with the DSL. Also a simple factory to get the right platform object.
+      #
+      # @param name [String] name of the platform
+      # @param block [Proc] DSL definition of the platform to call
+      def platform(name, &block)
+        @platform = case name
+                    when /^(aix|cisco-wrlinux|el|fedora|nxos|sles)-/
+                      Vanagon::Platform::RPM.new(@name)
+                    when /^huaweios-/
+                      Vanagon::Platform::RPM::WRL.new(@name)
+                    when /^(cumulus|debian|ubuntu)-/
+                      Vanagon::Platform::DEB.new(@name)
+                    when /^eos-/
+                      Vanagon::Platform::RPM::Swix.new(@name)
+                    when /^osx-/
+                      Vanagon::Platform::OSX.new(@name)
+                    when /^solaris-10/
+                      Vanagon::Platform::Solaris10.new(@name)
+                    when /^solaris-11/
+                      Vanagon::Platform::Solaris11.new(@name)
+                    else
+                      fail "Platform not implemented for '#{@name}' yet. Please go do so..."
+                    end
+
+        block.call(self)
+        @platform
+      end
+
+      # Accessor for the platform.
+      #
+      # @return [Vanagon::Platform] the platform the DSL methods will be acting against
+      def _platform
+        @platform
+      end
+
+      # All purpose getter. This object, which is passed to the platform block,
+      # won't have easy access to the attributes of the @platform, so we make a
+      # getter for each attribute.
+      #
+      # We only magically handle get_ methods, any other methods just get the
+      # standard method_missing treatment.
+      #
+      def method_missing(method, *args)
+        attribute_match = method.to_s.match(/get_(.*)/)
+        if attribute_match
+          attribute = attribute_match.captures.first
+        else
+          super
+        end
+
+        @platform.send(attribute)
+      end
+
+      # Set the path to make for the platform
+      #
+      # @param make_cmd [String] Full path to the make command for the platform
+      def make(make_cmd)
+        @platform.make = make_cmd
+      end
+
+      # Set the path to tar for the platform
+      #
+      # @param tar [String] Full path to the tar command for the platform
+      def tar(tar_cmd)
+        @platform.tar = tar_cmd
+      end
+
+      # Set the path to rpmbuild for the platform
+      #
+      # @param rpmbuild_cmd [String] Full path to rpmbuild with arguments to be used by default
+      def rpmbuild(rpmbuild_cmd)
+        @platform.rpmbuild = rpmbuild_cmd
+      end
+
+      # Set the path to the install command
+      # @param install_cmd [String] Full path to install with arguments to be used by default
+      def install(install_cmd)
+        @platform.install = install_cmd
+      end
+
+      # Set the path to patch for the platform
+      #
+      # @param patch_cmd [String] Full path to the patch command for the platform
+      def patch(patch_cmd)
+        @platform.patch = patch_cmd
+      end
+
+      # Sets the command to retrieve the number of cores available on a platform.
+      #
+      # @param num_cores_cmd [String] the command to retrieve the number of available cores on a platform.
+      def num_cores(num_cores_cmd)
+        @platform.num_cores = num_cores_cmd
+      end
+
+      # Set the command to turn the target machine into a builder for vanagon
+      #
+      # @param command [String] Command to enable the target machine to build packages for the platform
+      def provision_with(command)
+        @platform.provisioning << command
+      end
+
+      # Set the command to install any needed build dependencies for the target machine
+      #
+      # @param command [String] Command to install build dependencies for the target machine
+      # @param suffix [String] shell to be run after the main command
+      def install_build_dependencies_with(command, suffix = nil)
+        @platform.build_dependencies = OpenStruct.new({ :command => command, :suffix => suffix })
+      end
+
+      # Set the directory where service files or init scripts live for the platform
+      #
+      # @param dir [String] Directory where service files live on the platform
+      def servicedir(dir)
+        @platform.servicedir = dir
+      end
+
+      # Set the directory where default or sysconfig files live for the platform
+      #
+      # @param dir [String] Directory where default or sysconfig files live on the platform
+      def defaultdir(dir)
+        @platform.defaultdir = dir
+      end
+
+      # Set the servicetype for the platform so that services can be installed correctly.
+      #
+      # @param type [String] service type for the platform ('sysv' for example)
+      def servicetype(type)
+        @platform.servicetype = type
+      end
+
+      # Set the name of this platform as the vm pooler expects it
+      #
+      # @param name [String] name of the target template to use from the vmpooler
+      def vmpooler_template(name)
+        @platform.vmpooler_template = name
+      end
+
+      # Set the name of this platform as the vm pooler expects it
+      #
+      # @param name [String] name that the pooler uses for this platform
+      # @deprecated Please use vmpooler_template instead, this will be removed in a future vanagon release.
+      def vcloud_name(name)
+        warn "vcloud_name is a deprecated platform DSL method, and will be removed in a future vanagon release. Please use vmpooler_template instead."
+        self.vmpooler_template(name)
+      end
+
+      # Set the name of the docker image to use
+      #
+      # @param name [String] name of the docker image to use
+      def docker_image(name)
+        @platform.docker_image = name
+      end
+
+      # Set the port for ssh to use if it's not 22
+      #
+      # @param port [Integer] port number for ssh
+      def ssh_port(port = 22)
+        @platform.ssh_port = port
+      end
+
+      # Set the platform_triple for the platform
+      #
+      # @param triple[String] platform_triple for use in building out compiled
+      # tools and cross-compilation
+      def platform_triple(triple)
+        @platform.platform_triple = triple
+      end
+
+      # Set any codename this platform may have (debian for example)
+      #
+      # @param name [String] codename for this platform (squeeze for example)
+      def codename(name)
+        @platform.codename = name
+      end
+
+      # Helper to setup a apt repository on a target system
+      #
+      # @param definition [String] the repo setup file, must be a valid uri, fetched with curl
+      # @param gpg_key [String] optional gpg key to be fetched via curl and installed
+      def apt_repo(definition, gpg_key = nil)
+        # i.e., definition = http://builds.delivery.puppetlabs.net/puppet-agent/0.2.1/repo_configs/deb/pl-puppet-agent-0.2.1-wheezy.list
+        # parse the definition and gpg_key if set to ensure they are both valid URIs
+        definition = URI.parse definition
+        gpg_key = URI.parse gpg_key if gpg_key
+
+        self.provision_with "apt-get -qq update && apt-get -qq install curl"
+        if definition.scheme =~ /^(http|ftp)/
+          if File.extname(definition.path) == '.deb'
+            # repo definition is an deb (like puppetlabs-release)
+            self.provision_with "curl -o local.deb '#{definition}' && dpkg -i local.deb; rm -f local.deb"
+          else
+            reponame = "#{SecureRandom.hex}-#{File.basename(definition.path)}"
+            reponame = "#{reponame}.list" if File.extname(reponame) != '.list'
+            self.provision_with "curl -o '/etc/apt/sources.list.d/#{reponame}' '#{definition}'"
+          end
+        end
+
+        if gpg_key
+          gpgname = "#{SecureRandom.hex}-#{File.basename(gpg_key.path)}"
+          gpgname = "#{gpgname}.gpg" if gpgname !~ /\.gpg$/
+          self.provision_with "curl -o '/etc/apt/trusted.gpg.d/#{gpgname}' '#{gpg_key}'"
+        end
+
+        self.provision_with "apt-get -qq update"
+      end
+
+      # Helper to setup a yum repository on a target system
+      #
+      # @param definition [String] the repo setup URI or RPM file
+      def yum_repo(definition)
+        definition = URI.parse definition
+
+        self.provision_with "rpm -q curl > /dev/null || yum -y install curl"
+        if definition.scheme =~ /^(http|ftp)/
+          if File.extname(definition.path) == '.rpm'
+            # repo definition is an rpm (like puppetlabs-release)
+            if @platform.os_version.to_i < 6
+              # This can likely be done with just rpm itself (minus curl) however
+              # with a http_proxy curl has many more options avavailable for
+              # usage than rpm raw does. So for the most compatibility, we have
+              # chosen curl.
+              self.provision_with "curl -o local.rpm '#{definition}'; rpm -Uvh local.rpm; rm -f local.rpm"
+            else
+              self.provision_with "yum localinstall -y '#{definition}'"
+            end
+          else
+            reponame = "#{SecureRandom.hex}-#{File.basename(definition.path)}"
+            reponame = "#{reponame}.repo"  if File.extname(reponame) != '.repo'
+            if @platform.is_nxos? or @platform.is_cisco_wrlinux?
+              self.provision_with "curl -o '/etc/yum/repos.d/#{reponame}' '#{definition}'"
+            else
+              self.provision_with "curl -o '/etc/yum.repos.d/#{reponame}' '#{definition}'"
+            end
+          end
+        end
+      end
+
+      # Helper to setup a zypper repository on a target system
+      #
+      # @param definition [String] the repo setup URI or RPM file
+      def zypper_repo(definition)
+        definition = URI.parse definition
+        if @platform.os_version == '10'
+          flag = 'sa'
+        else
+          flag = 'ar'
+        end
+        self.provision_with "yes | zypper -n --no-gpg-checks install curl"
+        if definition.scheme =~ /^(http|ftp)/
+          if File.extname(definition.path) == '.rpm'
+            # repo definition is an rpm (like puppetlabs-release)
+            self.provision_with "curl -o local.rpm '#{definition}'; rpm -Uvh local.rpm; rm -f local.rpm"
+          else
+            self.provision_with "yes | zypper -n --no-gpg-checks #{flag} -t YUM --repo '#{definition}'"
+          end
+        end
+      end
+
+      # Generic adder for build repositories
+      #
+      # @param *args [Array<String>] List of arguments to pass on to the platform specific method
+      # @raise [Vanagon::Error] an arror is raised if the current platform does not define add_repository
+      def add_build_repository(*args)
+        if @platform.respond_to?(:add_repository)
+          self.provision_with @platform.send(:add_repository, *args)
+        else
+          raise Vanagon::Error, "Adding a build repository not defined for #{@platform.name}"
+        end
+      end
+    end
+  end
+end