pkgr 1.2.0 → 1.3.0

data/data/hooks/preinstall.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+set -e
+
+APP_USER="<%= user %>"
+
+if ! getent passwd "${APP_USER}" > /dev/null; then
+  if [ -f /etc/redhat-release ]; then
+    adduser "${APP_USER}" --user-group --system --create-home --shell /bin/bash
+  else
+    adduser "${APP_USER}" --disabled-login --group --system --quiet --shell /bin/bash
+  fi
+fi

data/{lib/pkgr/data/distributions/debian/sysv → data/init/sysv/lsb-3.1}/process.erb

@@ -26,7 +26,7 @@ pidfile="/var/run/${full_process_name}.pid"
 
 start() {
   # Run the program!
-  /usr/local/bin/${name} run ${process_name} >> /var/log/${name}/${process_name}-PROCESS_NUM.log 2>&1 &
+  ${name} run ${process_name} >> /var/log/${name}/${process_name}-PROCESS_NUM.log 2>&1 &
 
   # Generate the pidfile from here. If we instead made the forked process
   # generate it there will be a race condition between the pidfile writing
@@ -37,18 +37,86 @@ start() {
   return 0
 }
 
+subpids() {
+  local parent=$1
+  ps -o pid --ppid ${parent} --noheaders
+}
+
+process_kill() {
+  local pid=$1
+  local sig=$2
+  process_status $pid && kill -${sig} ${pid}
+}
+
+process_status() {
+  local pid=$1
+  if kill -0 $pid > /dev/null 2> /dev/null ; then
+    return 0
+  else
+    return 2
+  fi
+}
+
+stop_childs() {
+  local pids=$1
+
+  if [ ! "$pids" = "" ]; then
+    echo "Subprocesses detected ($pids), attempting to kill them first"
+    for pid in $pids ; do
+
+      # start in subshell, otherwise pid variable pollutes parent functions
+      (
+        stop_childs $(subpids $pid)
+      )
+
+      process_kill $pid "TERM"
+
+      for i in 1 2 3 4 5 ; do
+        echo -n "Waiting for pid $pid to die... "
+        process_status $pid || break
+        echo ""
+        sleep 1
+      done
+
+      if $(process_status $pid) ; then
+        echo "subprocess $pid stop failed; still running."
+        return 1
+      else
+        echo "stopped."
+      fi
+    done
+  fi
+}
+
+force_stop_childs() {
+  local pids=$1
+  for pid in $pids ; do
+    (
+      force_stop_childs $(subpids $pid)
+    )
+    process_kill $pid "KILL"
+  done
+}
+
+
 stop() {
   # Try a few times to kill TERM the program
   if status ; then
-    pid=`cat "$pidfile"`
+    local pid=`cat "$pidfile"`
     echo "Killing ${full_process_name} (pid $pid) with SIGTERM"
-    kill -TERM $pid
-    # Wait for it to exit.
-    for i in 1 2 3 4 5 ; do
-      echo "Waiting ${full_process_name} (pid $pid) to die..."
-      status || break
-      sleep 1
-    done
+
+    # start in subshell, otherwise pid variable pollutes parent functions
+    if ( stop_childs $(subpids $pid) ) ; then
+      process_kill $pid "TERM"
+
+      # Wait for it to exit.
+      for i in 1 2 3 4 5 ; do
+        echo "Waiting ${full_process_name} (pid $pid) to die..."
+        status || break
+        sleep 1
+      done
+    fi
+
     if status ; then
       echo "${full_process_name} stop failed; still running."
     else
@@ -59,7 +127,7 @@ stop() {
 
 status() {
   if [ -f "$pidfile" ] ; then
-    pid=`cat "$pidfile"`
+    local pid=`cat "$pidfile"`
     if kill -0 $pid > /dev/null 2> /dev/null ; then
       return 0
     else
@@ -72,8 +140,13 @@ status() {
 
 force_stop() {
   if status ; then
+    pid=$(cat "$pidfile")
     stop
-    status && kill -KILL `cat "$pidfile"`
+    # start in subshell, otherwise pid variable pollutes parent functions
+    (
+      force_stop_childs $(subpids $pid)
+    )
+    process_kill $pid "KILL"
   fi
 }
 

data/lib/pkgr.rb

@@ -14,7 +14,7 @@ module Pkgr
   end
 
   def data_dir
-    File.expand_path("../pkgr/data", __FILE__)
+    File.expand_path("../../data", __FILE__)
   end
   module_function :data_dir
 end

data/lib/pkgr/builder.rb

@@ -38,7 +38,7 @@ module Pkgr
     # Setup the build directory structure
     def setup
       Dir.chdir(build_dir) do
-        distribution.templates(config.name).each do |template|
+        distribution.templates(config).each do |template|
           template.install(config.sesame)
         end
       end
@@ -66,6 +66,12 @@ module Pkgr
         Pkgr.debug "Loading #{distribution.slug} from #{config_file}."
         @config = Config.load_file(config_file, distribution.slug).merge(config)
         Pkgr.debug "Found .pkgr.yml file. Updated config is now: #{config.inspect}"
+
+        # FIXME: make Config the authoritative source of the runner config (distribution only tells the default runner)
+        if @config.runner
+          type, *version = @config.runner.split("-")
+          distribution.runner = Distributions::Runner.new(type, version.join("-"))
+        end
       end
     end
 
@@ -162,7 +168,7 @@ module Pkgr
 
     # Path to the directory containing the main app files.
     def source_dir
-      File.join(build_dir, "opt/#{config.name}")
+      File.join(build_dir, config.home)
     end
 
     # Build directory. Will be used by fpm to make the package.

data/lib/pkgr/buildpack.rb

@@ -85,6 +85,7 @@ module Pkgr
     def install
       FileUtils.mkdir_p(buildpack_cache_dir)
       Dir.chdir(buildpack_cache_dir) do
+        puts "-----> Fetching buildpack #{url} at #{branch}"
         buildpack_install = Mixlib::ShellOut.new("git clone \"#{url}\"")
         buildpack_install.logger = Pkgr.logger
         buildpack_install.run_command

data/lib/pkgr/cli.rb

@@ -21,7 +21,7 @@ module Pkgr
       :desc => "Directory where to store the buildpacks",
       :default => Pkgr::Buildpack.buildpacks_cache_dir
 
-    desc "package TARBALL", "Package the given tarball or directory"
+    desc "package TARBALL", "Package the given tarball or directory, as a deb or rpm depending on the build machine"
 
     method_option :buildpack,
       :type => :string,
@@ -29,10 +29,6 @@ module Pkgr
     method_option :buildpack_list,
       :type => :string,
       :desc => "Specify a file containing a list of buildpacks to use (--buildpack takes precedence if given)"
-    method_option :target,
-      :type => :string,
-      :default => "deb",
-      :desc => "Target package to build (only 'deb' supported for now)"
     method_option :changelog,
       :type => :string,
       :desc => "Changelog"
@@ -43,6 +39,9 @@ module Pkgr
       :type => :string,
       :default => "x86_64",
       :desc => "Target architecture for the package"
+    method_option :runner,
+      :type => :string,
+      :desc => "Force a specific runner (e.g. upstart-1.5, sysv-lsb-1.3)"
     method_option :homepage,
       :type => :string,
       :desc => "Project homepage"
@@ -56,6 +55,10 @@ module Pkgr
       :type => :string,
       :default => Time.now.strftime("%Y%m%d%H%M%S"),
       :desc => "Package iteration (you should keep the default here)"
+    method_option :license,
+      :type => :string,
+      :default => nil,
+      :desc => "The license of your package (see <https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/#license-short-name>)"
     method_option :user,
       :type => :string,
       :desc => "User to run the app under (defaults to your app name)"
@@ -68,6 +71,9 @@ module Pkgr
     method_option :before_precompile,
       :type => :string,
       :desc => "Provide a script to run just before the buildpack compilation. Path will be resolved from the temporary code repository folder, so use absolute paths if needed."
+    method_option :after_precompile,
+      :type => :string,
+      :desc => "Provide a script to run just after the buildpack compilation. Path will be resolved from the temporary code repository folder, so use absolute paths if needed."
     method_option :dependencies,
       :type => :array,
       :default => [],
@@ -97,7 +103,7 @@ module Pkgr
       :desc => 'Specify environment variables for buildpack (--env "CURL_TIMEOUT=2" "BUNDLE_WITHOUT=development test")'
     method_option :force_os,
       :type => :string,
-      :desc => 'Force a specific distribution to build for (e.g. --force-os "debian-wheezy")'
+      :desc => 'Force a specific distribution to build for (e.g. --force-os "ubuntu-12.04"). This may result in a broken package.'
 
     def package(tarball)
       Pkgr.level = Logger::INFO if options[:verbose]

data/lib/pkgr/config.rb

@@ -3,12 +3,27 @@ require 'yaml'
 
 module Pkgr
   class Config < OpenStruct
+    DISTRO_COMPATIBILITY_MAPPING = {
+      "ubuntu-lucid" => "ubuntu-10.04",
+      "ubuntu-precise" => "ubuntu-12.04",
+      "debian-squeeze" => "debian-6",
+      "debian-wheezy" => "debian-7"
+    }
+
     class << self
       def load_file(path, distribution)
-        config = YAML.load_file(path)
+        config = YAML.load_file(path) || {}
         Pkgr.debug "Configuration from file: #{config.inspect} - Distribution: #{distribution.inspect}."
 
         targets = config.delete("targets") || {}
+
+        # backward compatibility
+        DISTRO_COMPATIBILITY_MAPPING.each do |from, to|
+          if targets.has_key?(from)
+            targets[to] = targets.delete(from)
+          end
+        end
+
         (targets[distribution.to_s] || {}).each do |k,v|
           config[k] = v
         end
@@ -128,6 +143,7 @@ module Pkgr
       end
     end
 
+    # TODO: DRY this with cli.rb
     def to_args
       args = [
         "--name \"#{name}\"",
@@ -137,7 +153,6 @@ module Pkgr
         "--iteration \"#{iteration}\"",
         "--homepage \"#{homepage}\"",
         "--architecture \"#{architecture}\"",
-        "--target \"#{target}\"",
         "--description \"#{description}\"",
         "--maintainer \"#{maintainer}\""
       ]
@@ -145,9 +160,12 @@ module Pkgr
       args.push "--build-dependencies #{build_dependencies.map{|d| "\"#{d}\""}.join}" unless build_dependencies.nil? || build_dependencies.empty?
       args.push "--compile-cache-dir \"#{compile_cache_dir}\"" unless compile_cache_dir.nil? || compile_cache_dir.empty?
       args.push "--before-precompile \"#{before_precompile}\"" unless before_precompile.nil? || before_precompile.empty?
+      args.push "--after-precompile \"#{after_precompile}\"" unless after_precompile.nil? || after_precompile.empty?
+      args.push "--license \"#{license}\"" unless license.nil? || license.empty?
       args.push "--buildpack \"#{buildpack}\"" unless buildpack.nil? || buildpack.empty?
       args.push "--buildpack_list \"#{buildpack_list}\"" unless buildpack_list.nil? || buildpack_list.empty?
       args.push "--force-os \"#{force_os}\"" unless force_os.nil? || force_os.empty?
+      args.push "--runner \"#{runner}\"" unless runner.nil? || runner.empty?
       args.push "--env #{env.variables.map{|v| "\"#{v}\""}.join(" ")}" if env.present?
       args.push "--auto" if auto
       args.push "--verbose" if verbose

data/lib/pkgr/distributions.rb

@@ -1,21 +1,23 @@
 require 'pkgr/templates/file_template'
 require 'pkgr/templates/dir_template'
-require 'pkgr/distributions/debian'
+require 'pkgr/distributions/base'
 require 'facter'
 
 module Pkgr
   module Distributions
     def current(force_os = nil)
-      distro = if force_os.nil?
-        [Facter.value('operatingsystem'), Facter.value('lsbdistcodename')]
+      os, release = if force_os.nil?
+        [Facter.value('operatingsystem'), Facter.value('operatingsystemrelease')]
       else
         force_os.split("-")
-      end.map(&:capitalize).join("")
+      end
 
-      klass = const_get(distro)
-      klass.new
+      os.downcase!
+
+      klass = const_get(os.capitalize)
+      klass.new(release)
     rescue NameError => e
-      raise Errors::UnknownDistribution, "Don't know about the current distribution you're on: #{distro}"
+      raise Errors::UnknownDistribution, "Don't know about the current distribution you're on: #{os}-#{release}"
     end
     module_function :current
   end

data/lib/pkgr/distributions/base.rb

@@ -0,0 +1,159 @@
+require 'pkgr/buildpack'
+require 'pkgr/env'
+require 'pkgr/distributions/runner'
+require 'yaml'
+
+module Pkgr
+  module Distributions
+    # Base components and behaviors for all distributions.
+    class Base
+      attr_reader :release
+      attr_writer :runner
+
+      def initialize(release)
+        @release = release
+      end
+
+      def os
+        self.class.name.split("::")[-1].downcase
+      end # def os
+
+      # e.g. ubuntu-12.04
+      def slug
+        [os, release].join("-")
+      end # def slug
+
+      def package_test_command(package)
+        raise NotImplementedError, "package_test_command must be implemented"
+      end
+
+      def package_install_command(packages)
+        raise NotImplementedError, "package_install_command must be implemented"
+      end
+
+      # Check if all build dependencies are present.
+      def check(config)
+        missing_packages = (build_dependencies(config.build_dependencies) || []).select do |package|
+          test_command = package_test_command(package)
+          Pkgr.debug "sh(#{test_command})"
+          ! system(test_command)
+        end
+
+        unless missing_packages.empty?
+          install_command = package_install_command(missing_packages)
+          if config.auto
+            package_install = Mixlib::ShellOut.new(install_command)
+            package_install.logger = Pkgr.logger
+            package_install.run_command
+            package_install.error!
+          else
+            Pkgr.warn("Missing build dependencies detected. Run the following to fix: #{install_command}")
+          end
+        end
+      end
+
+      # e.g. data/buildpacks/ubuntu/12.04
+      def default_buildpack_list
+        data_file(File.join("buildpacks", slug))
+      end # def default_buildpack_list
+
+      # Returns a list of Buildpack objects
+      def buildpacks(config)
+        custom_buildpack_uri = config.buildpack
+        if custom_buildpack_uri
+          uuid = Digest::SHA1.hexdigest(custom_buildpack_uri)
+          [Buildpack.new(custom_buildpack_uri, :custom, config.env)]
+        else
+          load_buildpack_list(config)
+        end
+      end # def buildpacks
+
+      def dependencies(other_dependencies = nil)
+        deps = YAML.load_file(data_file("dependencies", "#{os}.yml"))
+        (deps["default"] || []) | (deps[slug] || []) | (other_dependencies || [])
+      end # def dependencies
+
+      def build_dependencies(other_dependencies = nil)
+        deps = YAML.load_file(data_file("build_dependencies", "#{os}.yml"))
+        (deps["default"] || []) | (deps[slug] || []) | (other_dependencies || [])
+      end # def build_dependencies
+
+      # Returns a list of file and directory templates.
+      def templates(config)
+        app_name = config.name
+        list = []
+
+        # directories
+        [
+          "usr/bin",
+          config.home.gsub(/^\//, ""),
+          "etc/#{app_name}/conf.d",
+          "etc/default",
+          "etc/init",
+          "var/log/#{app_name}"
+        ].each{|dir| list.push Templates::DirTemplate.new(dir) }
+
+        list.push Templates::FileTemplate.new("etc/default/#{app_name}", data_file("environment", "default.erb"))
+        list.push Templates::FileTemplate.new("etc/logrotate.d/#{app_name}", data_file("logrotate", "logrotate.erb"))
+
+        # Put cli in /usr/bin, as redhat based distros don't have /usr/local/bin in their sudo PATH.
+        list.push Templates::FileTemplate.new("usr/bin/#{app_name}", data_file("cli", "cli.sh.erb"), mode: 0755)
+
+        # NOTE: /etc/appname/conf.d/* files are no longer installed here, since we don't want to overwrite any pre-existing config.
+        # They're now installed in the postinstall script.
+        list
+      end
+
+      # Returns a list of <Process, FileTemplate> tuples.
+      def initializers_for(app_name, procfile_entries)
+        list = []
+        procfile_entries.select(&:daemon?).each do |process|
+          Pkgr.debug "Adding #{process.inspect} to initialization scripts"
+          runner.templates(process, app_name).each do |template|
+            list.push [process, template]
+          end
+        end
+        list
+      end
+
+      def preinstall_file(config)
+        @preinstall_file ||= generate_hook_file("preinstall.sh", config)
+        @preinstall_file.path
+      end
+
+      def postinstall_file(config)
+        @postinstall_file ||= generate_hook_file("postinstall.sh", config)
+        @postinstall_file.path
+      end
+
+      protected
+
+      def load_buildpack_list(config)
+        file = config.buildpack_list || default_buildpack_list
+        return [] if file.nil?
+
+        File.read(file).split("\n").map do |line|
+          url, *raw_env = line.split(",")
+          buildpack_env = (config.env || Env.new).merge(Env.new(raw_env))
+          Buildpack.new(url, :builtin, buildpack_env)
+        end
+      end # def load_buildpack_list
+
+      def data_file(*names)
+        File.new(File.join(Pkgr.data_dir, *names))
+      end
+
+      def generate_hook_file(hook_name, config)
+        source = data_file("hooks", hook_name)
+        file = Tempfile.new("postinstall")
+        file.write ERB.new(File.read(source)).result(config.sesame)
+        file.rewind
+        file
+      end
+
+    end # class Base
+  end # module Distributions
+end # module Pkgr
+
+require 'pkgr/distributions/debian'
+require 'pkgr/distributions/redhat'