pkgr 1.3.2 → 1.4.0

data/data/hooks/preinstall.sh

@@ -9,9 +9,15 @@ export APP_HOME="<%= home %>"
 
 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
+    if ! getent group "${APP_GROUP}" > /dev/null ; then
+      groupadd --system "${APP_GROUP}"
+    fi
+    adduser "${APP_USER}" -g "${APP_GROUP}" --system --create-home --shell /bin/bash
   else
-    adduser "${APP_USER}" --disabled-login --group --system --quiet --shell /bin/bash
+    if ! getent group "${APP_GROUP}" > /dev/null; then
+      addgroup "${APP_GROUP}" --system --quiet
+    fi
+    adduser "${APP_USER}" --disabled-login --ingroup "${APP_GROUP}" --system --quiet --shell /bin/bash
   fi
 fi
 

data/data/hooks/preuninstall.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+set -e
+
+export APP_NAME="<%= name %>"
+export APP_USER="<%= user %>"
+export APP_GROUP="<%= group %>"
+export APP_HOME="<%= home %>"
+
+<% if before_remove && File.readable?(before_remove) %>
+CUSTOM_PREUNINSTALL_SCRIPT="<%= Base64.encode64 File.read(before_remove) %>"
+
+tmpfile=$(mktemp)
+chmod a+x "${tmpfile}"
+echo "${CUSTOM_PREUNINSTALL_SCRIPT}" | base64 -d - > ${tmpfile}
+
+"${tmpfile}" "$@"
+<% end %>

data/lib/pkgr/addon.rb

@@ -0,0 +1,110 @@
+module Pkgr
+  class Addon
+    attr_reader :nickname, :addons_dir
+    attr_reader :config
+
+    def initialize(nickname, addons_dir, config)
+      @nickname = nickname
+      @addons_dir = addons_dir
+      @config = config
+    end
+
+    def name
+      File.basename(url_without_branch, ".git").sub("addon-", "")
+    end
+
+    def url_without_branch
+      nickname.split("#")[0].sub(/\.git$/,'')
+    end
+
+    def url
+      if nickname.start_with?("http")
+        url_without_branch
+      else
+        user, repo = nickname.split("/", 2)
+        user, repo = "pkgr", user if repo.nil?
+        repo = "addon-#{repo}" unless repo.start_with?("addon-")
+
+        "https://github.com/#{user}/#{repo}"
+      end
+    end
+
+    def branch
+      nickname.split("#")[1] || "master"
+    end
+
+    def tarball_url
+      "#{url}/archive/#{branch}.tar.gz"
+    end
+
+    def debian_dependency_name
+      [
+        [config.name, name].join("-"),
+        "(= #{config.version}-#{config.iteration})"
+      ].join(" ")
+    end
+
+    def debtemplates
+      debtemplates_file = File.join(dir, "debian", "templates")
+      if File.exists?(debtemplates_file)
+        File.new(debtemplates_file)
+      else
+        StringIO.new
+      end
+    end
+
+    def debconfig
+      debconfig_file = File.join(dir, "debian", "config")
+      if File.exists?(debconfig_file)
+        File.new(debconfig_file)
+      else
+        StringIO.new
+      end
+    end
+
+    def install!(src_dir)
+      install_addon = Mixlib::ShellOut.new %{curl -L --max-redirs 3 --retry 5 -s '#{tarball_url}' | tar xzf - --strip-components=1 -C '#{dir}'}
+      install_addon.logger = Pkgr.logger
+      install_addon.run_command
+      install_addon.error!
+
+      # TODO: remove args from command once all addons use env variables
+      compile_addon = Mixlib::ShellOut.new(%{#{dir}/bin/compile '#{config.name}' '#{config.version}' '#{config.iteration}' '#{src_dir}' 2>&1}, {
+        :environment => {
+          "APP_NAME" => config.name,
+          "APP_VERSION" => config.version,
+          "APP_ITERATION" => config.iteration,
+          "APP_SAFE_NAME" => config.name.gsub("-", "_"),
+          "APP_USER" => config.user,
+          "APP_GROUP" => config.group,
+          "APP_WORKSPACE" => src_dir
+        }
+      })
+      compile_addon.logger = Pkgr.logger
+      compile_addon.live_stream = LiveStream.new(STDOUT)
+      compile_addon.run_command
+      compile_addon.error!
+    end
+
+    def dir
+      @dir ||= begin
+        directory = File.join(addons_dir, File.basename(name))
+        FileUtils.mkdir_p(directory)
+        directory
+      end
+    end
+
+    class LiveStream
+      attr_reader :stream
+      def initialize(stream = STDOUT)
+        @stream = stream
+      end
+
+      def <<(data)
+        data.split("\n").each do |line|
+          stream.puts "       #{line}"
+        end
+      end
+    end
+  end
+end

data/lib/pkgr/builder.rb

@@ -3,6 +3,9 @@ require 'fileutils'
 require 'pkgr/config'
 require 'pkgr/distributions'
 require 'pkgr/process'
+require 'pkgr/addon'
+require 'pkgr/cron'
+require 'pkgr/installer'
 
 module Pkgr
   class Builder
@@ -21,31 +24,23 @@ module Pkgr
       update_config
       check
       setup
+
+      if config.installer
+        setup_pipeline
+      else
+        setup_addons
+      end
+
       compile
       write_env
       write_init
+      setup_crons
       package
+      store_cache
     ensure
       teardown if config.clean
     end
 
-    # Check configuration, and verifies that the current distribution's requirements are satisfied
-    def check
-      raise Errors::ConfigurationInvalid, config.errors.join("; ") unless config.valid?
-      distribution.check(config)
-    end
-
-    # Setup the build directory structure
-    def setup
-      Dir.chdir(build_dir) do
-        # useful for templates that need to read files
-        config.source_dir = source_dir
-        distribution.templates(config).each do |template|
-          template.install(config.sesame)
-        end
-      end
-    end
-
     # Extract the given tarball to the target directory
     def extract
       FileUtils.mkdir_p source_dir
@@ -69,12 +64,62 @@ module Pkgr
         @config = Config.load_file(config_file, distribution.slug).merge(config)
         Pkgr.debug "Found .pkgr.yml file. Updated config is now: #{config.inspect}"
 
+        # update distribution config
+        distribution.config = @config
+
         # 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
+      # required to build proper Addon objects
+      config.addons_dir = addons_dir
+      # useful for templates that need to read files
+      config.source_dir = source_dir
+      config.build_dir = build_dir
+    end
+
+    def pipeline
+      @pipeline ||= begin
+        components = []
+        unless config.wizards.empty? || config.installer == false
+          components << Installer.new(config.installer, distribution).setup
+        end
+        components
+      end
+    end
+
+    # Check configuration, and verifies that the current distribution's requirements are satisfied
+    def check
+      raise Errors::ConfigurationInvalid, config.errors.join("; ") unless config.valid?
+      distribution.check
+    end
+
+    # Setup the build directory structure
+    def setup
+      Dir.chdir(build_dir) do
+        distribution.templates.each do |template|
+          template.install(config.sesame)
+        end
+      end
+    end
+
+    def setup_pipeline
+      pipeline.each do |component|
+        @config = component.call(config)
+      end
+    end
+
+    # LEGACY, remove once openproject no longer needs it
+    # If addons are declared in .pkgr.yml, add them
+    def setup_addons
+      config.addons.each do |addon|
+        puts "-----> [addon] #{addon.name} (#{addon.url} @ #{addon.branch})"
+        addon.install!(source_dir)
+        dependency = distribution.add_addon(addon)
+        config.dependencies.push(dependency) if dependency
+      end
     end
 
     # Pass the app through the buildpack
@@ -126,6 +171,20 @@ module Pkgr
       end
     end
 
+    # Write cron files
+    def setup_crons
+      crons_dir = File.join("/", distribution.crons_dir)
+
+      config.crons.map! do |cron_path|
+        Cron.new(File.expand_path(cron_path, config.home), File.join(crons_dir, File.basename(cron_path)))
+      end
+
+      config.crons.each do |cron|
+        puts "-----> [cron] #{cron.source} => #{cron.destination}"
+      end
+    end
+
+
     # Launch the FPM command that will generate the package.
     def package
       app_package = Mixlib::ShellOut.new(fpm_command)
@@ -134,6 +193,13 @@ module Pkgr
       app_package.error!
     end
 
+    def store_cache
+      return true unless config.store_cache
+      generate_cache_tarball = Mixlib::ShellOut.new %{tar czf cache.tar.gz -C #{compile_cache_dir} .}
+      generate_cache_tarball.logger = Pkgr.logger
+      generate_cache_tarball.run_command
+    end
+
     # Make sure to get rid of the build directory
     def teardown
       FileUtils.rm_rf(build_dir)
@@ -182,6 +248,10 @@ module Pkgr
       File.join(source_dir, "vendor", "pkgr")
     end
 
+    def addons_dir
+      File.join(vendor_dir, "addons")
+    end
+
     # Directory where binstubs will be created for the corresponding Procfile commands.
     def proc_dir
       File.join(vendor_dir, "processes")
@@ -203,12 +273,12 @@ module Pkgr
 
     # Returns the current distribution we're packaging for.
     def distribution
-      @distribution ||= Distributions.current(config.force_os)
+      @distribution ||= Distributions.current(config)
     end
 
     # List of available buildpacks for the current distribution.
     def buildpacks
-      distribution.buildpacks(config)
+      distribution.buildpacks
     end
 
     # Buildpack detected for the app, if any.
@@ -221,14 +291,14 @@ module Pkgr
     end
 
     def fpm_command
-      distribution.fpm_command(build_dir, config)
+      distribution.fpm_command(build_dir)
     end
 
     protected
     def run_hook(file)
       return true if file.nil?
 
-      cmd = %{env -i PATH="$PATH"#{config.env} bash '#{file}' 2>&1}
+      cmd = %{env -i APP_NAME="#{config.name}" PATH="$PATH"#{config.env} bash '#{file}' 2>&1}
 
       Pkgr.logger.debug "Running hook in #{source_dir}: #{file.inspect}"
       puts "-----> Running hook: #{file.inspect}"

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, as a deb or rpm depending on the build machine"
+    desc "package TARBALL|DIRECTORY", "Package the given tarball or directory, as a deb or rpm depending on the build machine"
 
     method_option :buildpack,
       :type => :string,
@@ -110,6 +110,9 @@ module Pkgr
     method_option :force_os,
       :type => :string,
       :desc => 'Force a specific distribution to build for (e.g. --force-os "ubuntu-12.04"). This may result in a broken package.'
+    method_option :store_cache,
+      :type => :boolean,
+      :desc => 'Output a tarball of the cache in the current directory (name: cache.tar.gz)'
 
     def package(tarball)
       Pkgr.level = Logger::INFO if options[:verbose]
@@ -122,13 +125,13 @@ module Pkgr
     rescue => e
       Pkgr.debug "#{e.class.name} : #{e.message}"
       e.backtrace.each{|line| Pkgr.debug line}
-      puts "  ! ERROR: #{e.message}"
+      puts "     ! ERROR: #{e.message}"
       exit 1
     # Only used for logging. Re-raise immediately.
     rescue Exception => e
       Pkgr.debug "#{e.class.name} : #{e.message}"
       e.backtrace.each{|line| Pkgr.debug line}
-      puts "  ! SYSTEM ERROR: #{e.class.name} : #{e.message}"
+      puts "     ! SYSTEM ERROR: #{e.class.name} : #{e.message}"
       raise e
     end
   end

data/lib/pkgr/command.rb

@@ -0,0 +1,102 @@
+require 'logger'
+require 'mixlib/shellout'
+
+module Pkgr
+class Command
+  class CommandFailed < RuntimeError; end
+
+  attr_accessor :logger, :log_tag
+
+  class << self
+    attr_accessor :default_timeout
+    default_timeout = 60
+  end
+
+  def initialize(logger = nil, log_tag = nil)
+    @logger = logger || Logger.new(STDOUT)
+    @log_tag = log_tag
+  end
+
+  def stream!(command, env = {})
+    _stream(command, {env: env, fail: true, live_stream: logger})
+  end
+
+  def stream(command, env = {})
+    _stream(command, {env: env, live_stream: logger})
+  end
+
+  def capture!(command, error_message, env = {})
+    value = _run(command, {env: env, fail: true})
+    value = yield(value) if block_given?
+    value
+  end
+
+  def capture(command, env = {})
+    value = _run(command, {env: env})
+    value = yield(value) if block_given?
+    value
+  end
+
+  def run(command, env = {})
+    _run(command, {env: env})
+  end
+
+  def run!(command, env = {})
+    _run(command, {env: env, fail: true})
+  end
+
+  def _stream(command, opts = {})
+    env = opts[:env] || {}
+    fail = !! opts[:fail]
+    env_string = env.map{|(k,v)| [k,"\"#{v}\""].join("=")}.join(" ")
+
+    logger.debug "sh(#{command})"
+
+    IO.popen("#{env_string} #{command}") do |io|
+      until io.eof?
+        data = io.gets
+        puts data
+      end
+    end
+
+    raise CommandFailed, "Failure during packaging" if fail && ! $?.exitstatus.zero?
+  # raised when file does not exist
+  rescue Errno::ENOENT, RuntimeError => e
+    raise CommandFailed, e.message
+  end
+
+  def _run(command, opts = {})
+    env = opts[:env] || {}
+    live_stream = opts[:live_stream]
+    fail = !! opts[:fail]
+
+    cmd = Mixlib::ShellOut.new(
+      command,
+      environment: env,
+      timeout: self.class.default_timeout
+    )
+
+    # live stream is buggy, using IO.popen instead
+    # cmd.live_stream = logger if live_stream
+    cmd.logger = logger
+    cmd.log_level = :debug
+    cmd.log_tag = log_tag if log_tag
+    cmd.run_command
+
+    cmd.error! if fail
+
+    cmd.stdout.chomp
+  rescue RuntimeError, Errno::ENOENT => e
+    logger.error "Command failed: #{e.message}"
+
+    msg = ["Command failed"]
+    cmd.stdout.split("\n").each do |line|
+      msg.push "STDOUT -- #{line}"
+    end
+    cmd.stderr.split("\n").each do |line|
+      msg.push "STDERR -- #{line}"
+    end
+    raise CommandFailed, msg.join("\n")
+  end
+end
+end