pkgr 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Cyril Rohr
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+# pkgr
+
+Plug this [Railtie](http://api.rubyonrails.org/classes/Rails/Railtie.html)
+into your Rails 3 app (ruby1.9 only), and you'll be ready to package your
+Rails app as a DEB or RPM (coming soon) package.
+
+## Why?
+
+[Capistrano](http://capify.org/) is great for deploying Rails/Ruby
+applications, but the deployment recipe can quickly become a mess, and scaling
+the deployment to more than a few servers can prove to be difficult. Plus, if
+you're already using automation tools such as
+[Puppet](http://www.puppetlabs.com/) to configure your servers, you have to
+run two different processes to configure your infrastructure.
+
+Another issue with Capistrano is that the hook system is not that powerful.
+Compare that with the pre/post-install/upgrade/uninstall steps that you can
+define in a RPM or DEB package, and you'll quickly see the advantage of
+letting a robust package manager such as `apt` or `yum` handle all those
+things for you in a reliable manner.
+
+Last thing, once you built your RPM or DEB package and you tested that it
+works once, you can deploy it on any number of servers at any time and you're
+sure that it will install the required package dependencies, run the hooks,
+and put the files in the directories you specified, creating them as needed.
+Then, you can downgrade or uninstall the whole application in one command.
+
+## How?
+
+The issue with Ruby applications is that most of the gems are not (yet)
+packaged in the various Linux distributions. And even if they were, installing
+multiple Ruby applications that need two different versions of the same Ruby
+library would be impossible, since you can't install two different (minor)
+versions of a library with the package managers.
+
+So, how are we going to easily package Ruby applications and avoid dependency
+issues? Well, I know package maintainers will scream at me, but we'll just
+vendor the required gems in the package we'll build, and use bundler to manage
+those dependencies. Thus, the only dependency we'll put in our package will be
+the Ruby1.9 (+rubygems).
+
+## What?
+
+This gem will allow you to package your Rails3 application, create an `init.d`
+script for you, install a binary file to start your app/rake tasks/console,
+put your configuration files in `/etc/app-name/`, setup a proper logrotate
+file so that your log files don't eat all the disk space of your server, and a
+few other things.
+
+The default target installation directory for the other app files will be
+`/opt/local/app-name`. This can be configured.
+
+## Usage
+
+Declare `pkgr` as one of your **development** dependencies in your `Gemfile`:
+
+    group :development do
+      gem 'pkgr'
+    end
+
+Now make sure you have all the gems installed:
+
+    bundle install
+
+`pkgr` will install a number of new rake tasks to handle the packaging
+workflow. But first, you'll have to create a configuration file to get it
+working:
+
+    rake pkgr:setup
+
+This will create a configuration file at `config/pkgr.yml`. Edit it, and fill
+in details about the `name` of your application, description, and the list of
+runtime dependencies it depends on. Same for dependencies required at build
+time only (most of the time, development headers).
+
+Now you can generate all the files required for building a debian package:
+
+    rake pkgr:generate
+
+A new directory `debian/` should have been created. You can have a look at it,
+but you should not have to edit anything manually.
+
+Once you're ready to package your app, just run the following steps:
+
+* Increment the version number:
+
+        rake pkgr:bump:patch # or rake pkgr:bump:minor or rake pkgr:bump:major
+
+* Re-generate the debian files:
+
+        rake pkgr:generate
+
+* Commit your changes (the `pkgr` app will `git archive HEAD`, which means all
+  your changes must be committed first -- we may want to change this):
+
+        commit -am "..."
+
+* Build the package on your machine (default, but you better be running a
+  Debian Squeeze), or on a remote machine (recommended, for instance you can
+  get a Vagrant VM in no time):
+
+        HOST=debian-build-machine rake pkgr:build:deb
+        # or HOST=localhost rake pkgr:build:deb, or just rake pkgr:build:deb
+
+  Note that the user with which you're connecting to the build machine **must
+  have `sudo` privileges** (required to install build and runtime
+  dependencies).
+
+  Also, it's most likely that you'll have to do this a few times at first, as
+  well as adding missing runtime and build dependencies, before your app can
+  be successfully packaged.
+
+* Your .deb package should be made available in the `pkg` directory of your
+  app. Next step is probably to upload it to a local apt repository, and then
+  a simple `apt-get install my-app` will install everything. Enjoy!
+
+
+
+## Requirements
+
+* You must use Rails3+ and ruby1.9+ in your application. This may work with
+  other rubies but then you'll need to add a rubygems dependency.
+
+* Your Rails application must be able to run with the
+  [`thin`](http://code.macournoyer.com/thin/) web server. Don't forget to add
+  `thin` to your Gemfile!
+
+* Your application must be checked into a **Git** repository. Your name and
+  email is taken from the git configuration, and the changelog is populated
+  based on the git log between two versions.
+
+## TODO
+
+* Speed up the packaging process (currently, bundler re-downloads all the gems
+  each time you package an app).
+
+* Include tasks for building RPMs.
+
+* Better debian initd script.
+
+* Some tests.
+
+## Authors
+
+* Cyril Rohr <cyril.rohr@gmail.com> - <http://crohr.me>
+
+## Copyright
+
+See LICENSE (MIT)

data/lib/pkgr.rb

@@ -0,0 +1,35 @@
+require 'pkgr/app'
+require 'pkgr/railtie' if defined?(Rails)
+
+module Pkgr
+  DEBIAN_DIR = "debian"
+
+  def self.setup(root)
+    setup_config(root)
+  end
+
+  protected
+
+  def self.setup_config(root)
+    puts "Setting up configuration file..."
+    target = File.join(root, "config", "pkgr.yml")
+    FileUtils.mkdir_p(File.dirname(target))
+    if File.exist?(target)
+      puts "'#{target}' already exists. Skipped."
+    else
+      FileUtils.cp(File.expand_path("../pkgr/data/pkgr.yml", __FILE__), target, :verbose => true)
+      puts "Edit '#{target}' and fill in the required information, then enter 'rake pkgr:generate:debian' to generate the debian control files."
+    end
+  end
+
+  
+  def self.mkdir(target)
+    if File.directory?(target)
+      puts "#{target} directory already exists. Skipped."
+    elsif File.file?(target)
+      raise "#{target} already exists and is a file. Aborting."
+    else
+      FileUtils.mkdir_p target, :verbose => true
+    end
+  end
+end

data/lib/pkgr/app.rb

@@ -0,0 +1,246 @@
+require 'rake'
+require 'erb'
+
+module Pkgr
+  class App
+    include RakeFileUtils
+    attr_reader :root
+    attr_reader :errors
+    attr_reader :config
+
+    # +root+: the root directory of the app.
+    # +config+ a Configuration object, hosting the parameters defined in `config/pkgr.yml`.
+    def initialize(root, config_path)
+      @root = root
+      load_config(config_path)
+      @errors = []
+    end
+
+    def load_config(path)
+      @config = YAML::load_file(path)
+      raise ArgumentError, "The given configuration file at '#{path}' is not a well-formed YAML file. Please fix it or remove it and run 'rake pkgr:setup'" unless @config.kind_of?(Hash)
+      @config['_path'] = path
+    end
+    
+    def write_config
+      File.open(@config['_path'] || raise("Don't know where to save myself!"), "w+") {|f|
+        YAML.dump(@config.reject{|k,v| k == '_path'}, f)
+      }
+    end
+
+    # Returns true if the app is correctly configured. Else otherwise.
+    def valid?
+      @errors.clear
+      @errors.push("is not a valid git repository") unless File.exist?(File.join(@root, ".git", "HEAD"))
+      @errors.push("must have a name") unless @config.fetch('name')
+      @errors.push("must have a valid name ([a-zA-Z0-9_-])") unless @config.fetch('name').scan(/[^a-z0-9\_\-]/i)
+      @errors.push("must have a version") unless @config.fetch('version')
+      @errors.push("must have a valid target architecture") unless @config.fetch('architecture')
+      @errors.empty?
+    end
+
+    def generate_required_files
+      setup_debian
+      setup_binary
+    end
+
+    def git_ref
+      @config.fetch('git_ref') { 'HEAD' }
+    end
+
+    def prefix
+      @config.fetch('prefix') { "/opt/local" }
+    end
+
+    def author_name
+      @author_name ||= `git config --get user.name`.chomp
+    end
+
+    def author_email
+      @author_email ||= `git config --get user.email`.chomp
+    end
+
+    def name
+      @config['name']
+    end
+
+    def description
+      @config['description'] || ""
+    end
+
+    def debian_build_dependencies(installable_only = false)
+      deps = @config['debian_build_dependencies'] || []
+      if installable_only
+        deps = deps.reject{|d| d =~ /[\$\{\}]/}.map{|d| d.split(/\s/)[0]}
+      end
+      deps
+    end
+
+    def debian_runtime_dependencies(installable_only = false)
+      deps = @config['debian_runtime_dependencies'] || []
+      if installable_only
+        deps = deps.reject{|d| d =~ /[\$\{\}]/}.map{|d| d.split(/\s/)[0]}
+      end
+      deps
+    end
+
+    def architecture
+      @config['architecture'] || "all"
+    end
+
+    def homepage
+      @config['homepage'] || ""
+    end
+
+    def config_files
+      @config['config_files'] || []
+    end
+
+    def version
+      @config['version']
+    end
+    
+    def user
+      @config.fetch('user') { name }
+    end
+    
+    def group
+      @config.fetch('group') { name }
+    end
+
+    # prefix without the leading slash.
+    def pkg_prefix
+      prefix[1..-1]
+    end
+
+    def setup_debian
+      target = File.join(root, Pkgr::DEBIAN_DIR)
+      Pkgr.mkdir(target)
+
+      Dir[File.expand_path("../data/debian/*", __FILE__)].each do |file|
+        case File.extname(file)
+        when ".erb"
+          file_target = File.join(target, File.basename(file, ".erb"))
+          File.open(file_target, "w+") do |f|
+            f << ERB.new(File.read(file)).result(binding)
+          end
+        else
+          file_target = File.join(target, File.basename(file))
+          if File.exist?(file_target)
+            puts "File #{file_target} already exists. Skipped."
+          else
+            FileUtils.cp(file, file_target, :verbose => true)
+          end
+        end
+      end
+
+      puts "Correctly set up debian files."
+    end
+
+    # Creates an executable file for easy launch of the server/console/rake tasks once it is installed.
+    # E.g. /usr/bin/my-app console, /usr/bin/my-app server start -p 8080
+    def setup_binary
+      target = File.join(root, "bin", name)
+      Pkgr.mkdir(File.dirname(target))
+      FileUtils.cp(File.expand_path("../data/bin/executable", __FILE__), target, :verbose => true)
+      FileUtils.chmod 0755, target, :verbose => true
+      puts "Correctly set up executable file. Try running './bin/#{name} console'."
+    end
+
+    # FIXME: this is ugly
+    def bump!(version_index = :patch)
+      indices = [:major, :minor, :patch]
+      index = indices.index(version_index) || raise(ArgumentError, "The given version index is not valid (#{version_index})")
+      version = @config.fetch('version') { '0.0.0' }
+      fragments = version.split(".")
+      fragments[index] = fragments[index].to_i+1
+      ((index+1)..2).each{|i|
+        fragments[i] = 0
+      }
+      new_version = fragments.join(".")
+
+      changelog = File.read(debian_file("changelog"))
+
+      last_commit = changelog.scan(/\s+\* ([a-z0-9]{7}) /).flatten[0]
+
+      cmd = "git log --oneline"
+      cmd << " #{last_commit}..#{git_ref}" unless last_commit.nil?
+      result = %x{#{cmd}}
+      ok = $?.exitstatus == 0
+      if !ok
+        raise "Command failed. Aborting."
+      else
+        content_changelog = [
+          "#{name} (#{new_version}-1) unstable; urgency=low",
+          "",
+          result.split("\n").reject{|l| l =~ / v#{version}/}.map{|l| "  * #{l}"}.join("\n"),
+          "",
+          " -- #{author_name} <#{author_email}>  #{Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")}",
+          "",
+          changelog
+        ].join("\n")
+
+        File.open(debian_file("changelog"), "w+") do |f|
+          f << content_changelog
+        end
+
+        @config['version'] = new_version
+        write_config
+
+        puts "Committing changelog and version file..."
+        files_to_commit = [debian_file('changelog'), @config['_path']]
+        sh "git add #{files_to_commit.join(" ")} && git commit -m 'v#{new_version}' #{files_to_commit.join(" ")}"
+      end
+    end
+
+    def build_debian_package(host)
+      puts "Building debian package on '#{host}'..."
+      Dir.chdir(root) do
+        Pkgr.mkdir("pkg")
+        case host
+        when 'localhost'
+          debian_steps.each do |step|
+            sh step
+          end
+        else
+          archive = "#{name}-#{version}"
+          sh "scp #{File.expand_path("../data/config/pre_boot.rb", __FILE__)} #{host}:/tmp/"
+          cmd = %Q{
+            git archive #{git_ref} --prefix=#{archive}/ | ssh #{host} 'cat - > /tmp/#{archive}.tar &&
+              set -x && rm -rf /tmp/#{archive} &&
+              cd /tmp && tar xf #{archive}.tar && cd #{archive} &&
+              cat config/boot.rb >> /tmp/pre_boot.rb && cp -f /tmp/pre_boot.rb config/boot.rb &&
+              #{debian_steps.join(" &&\n")}'
+          }
+          sh cmd
+          # Fetch the .deb, and put it in the `pkg` directory
+          sh "scp #{host}:/tmp/#{name}_#{version}*.deb pkg/"
+        end
+      end
+    end
+
+    def debian_steps
+      target_vendor = "vendor/bundle/ruby/1.9.1"
+      [
+        "sudo apt-get install #{debian_runtime_dependencies(true).join(" ")} -y",
+        "sudo apt-get install #{debian_build_dependencies(true).join(" ")} -y",
+        # Vendor bundler
+        "gem1.9.1 install bundler --no-ri --no-rdoc --version #{bundler_version} -i #{target_vendor}",
+        "GEM_HOME='#{target_vendor}' #{target_vendor}/bin/bundle install --deployment --without test development",
+        "rm -rf #{target_vendor}/{cache,doc}",
+        "dpkg-buildpackage -us -uc -d"
+      ]
+    end
+
+    private
+    def bundler_version
+      @config.fetch('bundler_version') { '1.1.3' }
+    end
+
+    def debian_file(filename)
+      file = File.join(Pkgr::DEBIAN_DIR, filename)
+      return nil unless File.exist?(file)
+      file
+    end
+  end
+end

data/lib/pkgr/data/bin/executable

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+
+config = YAML.load_file(::File.expand_path("../../config/pkgr.yml", __FILE__))
+
+require ::File.expand_path("../../config/boot", __FILE__)
+
+supported_commands = ["server", "rake", "console"]
+command = ARGV.shift
+
+case command
+when "rake"
+  ENV['RACK_ENV'] ||= "production"
+  ARGV << "-f" << ::File.expand_path("../../Rakefile", __FILE__)
+  require 'rake'
+  Rake.application.run
+when "console"
+  APP_PATH = ::File.expand_path('../../config/application',  __FILE__)
+  require ::File.expand_path('../../config/boot',  __FILE__)
+  ARGV.push("production") if ARGV.empty?
+  ARGV.unshift("console")
+  require 'rails/commands'
+when "server"
+  require 'thin'
+  rackup_file = ::File.expand_path('../../config.ru',  __FILE__)
+  argv = ARGV
+  argv << ["-R", rackup_file] unless ARGV.include?("-R")
+  argv << ["-p", "8000"] unless ARGV.include?("-p")
+  argv << ["-e", "production"] unless ARGV.include?("-e")
+  argv << ["--tag", "#{config['name']}-#{config['version']}"] unless ARGV.include?("--tag")
+  Thin::Runner.new(argv.flatten).run!
+else
+  STDERR.puts "You must choose one of the following commands: #{supported_commands.inspect}"
+  exit(1)
+end

data/lib/pkgr/data/config/pre_boot.rb

@@ -0,0 +1,15 @@
+# This part of code is added by Pkgr, before the original content of the
+# `config/boot.rb` file.
+require 'rubygems'
+
+# Attempts to use a vendored Bundler, if any
+vendored_gems = File.expand_path(
+  '../../vendor/bundle/ruby/1.9.1/gems', __FILE__
+)
+
+vendored_bundler = Dir["#{vendored_gems}/bundler-*/lib"].sort.last
+
+if !vendored_bundler.nil? && !$LOAD_PATH.include?(vendored_bundler)
+  $LOAD_PATH.unshift(vendored_bundler)
+end
+

data/lib/pkgr/data/debian/compat.erb

@@ -0,0 +1 @@
+7

data/lib/pkgr/data/debian/control.erb

@@ -0,0 +1,12 @@
+Source: <%= name %>
+Section: unknown
+Priority: extra
+Maintainer: <%= author_name %> <<%= author_email %>>
+Build-Depends: <%= debian_build_dependencies.join(",") %>
+Standards-Version: 3.7.3
+Homepage: <%= homepage %>
+
+Package: <%= name %>
+Architecture: <%= architecture %>
+Depends: <%= debian_runtime_dependencies.join(", ") %>
+Description: <%= description %>

data/lib/pkgr/data/debian/copyright.erb

@@ -0,0 +1,17 @@
+This package was debianized by Pkgr <http://crohr.me/pkgr> on <%= Time.now.to_s %>.
+
+It was downloaded from <ssh://somewhere>
+
+Upstream Author(s):
+
+    <%= author_name %> <<%=author_email %>>
+
+Copyright:
+
+    Some copyright here
+
+License:
+
+    <Put the license of the package here indented by 4 spaces>
+
+The Debian packaging is public domain.

data/lib/pkgr/data/debian/cron.d

@@ -0,0 +1,4 @@
+#
+# Put your cron tasks here
+#
+# 0 4	* * *	root	[ -x /usr/bin/some_script ] && /usr/bin/some_script

data/lib/pkgr/data/debian/default.erb

@@ -0,0 +1,11 @@
+# Defaults for <%= name %> initscript
+# sourced by /etc/init.d/<%= name %>
+# installed at /etc/default/<%= name %> by the maintainer scripts
+
+#
+# This is a POSIX shell fragment
+#
+
+# Additional options that are passed to the Daemon.
+DAEMON_OPTS="server -d --pid $PIDFILE --user $NAME --group $NAME --log /var/log/$NAME/thin.log"
+

data/lib/pkgr/data/debian/dirs.erb

@@ -0,0 +1,2 @@
+var/log/<%= name %>
+var/db/<%= name %>

data/lib/pkgr/data/debian/init.d.erb

@@ -0,0 +1,155 @@
+#! /bin/sh
+#
+### BEGIN INIT INFO
+# Provides:          <%= name %>
+# Required-Start:    $remote_fs $syslog
+# Required-Stop:     $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start <%= name %> app at boot time.
+# Description:       Enable service provided by <%= name %>.
+### END INIT INFO
+#
+
+PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+NAME="<%= name %>"
+DAEMON=/usr/bin/$NAME
+DESC=$NAME
+
+test -x $DAEMON || exit 0
+
+LOGDIR=/var/log/$NAME
+PIDFILE=/var/run/$NAME.pid
+DODTIME=5                   # Time to wait for the server to die, in seconds
+                            # If this value is set too low you might not
+                            # let some servers to die gracefully and
+                            # 'restart' will not work
+
+# Include defaults if available
+if [ -f /etc/default/$NAME ] ; then
+  . /etc/default/$NAME
+fi
+
+set -e
+
+
+running_pid()
+{
+    # Check if a given process status name matches a given name
+    pid=$1
+    name=$2
+    [ -z "$pid" ] && return 1
+    [ ! -d /proc/$pid ] &&  return 1
+    cmd=`cat /proc/$pid/status | grep Name: | cut -f 2`
+    # Is this the expected child?
+    [ "$cmd" != "$name" ] &&  return 1
+    return 0
+}
+
+running()
+{
+  # Check if the process is running looking at /proc
+  # (works for all users)
+    # No pidfile, probably no daemon present
+    [ ! -f "$PIDFILE" ] && return 1
+    # Obtain the pid
+    pid=`cat $PIDFILE`
+    running_pid $pid $NAME || return 1
+    return 0
+}
+
+force_stop() {
+# Forcefully kill the process
+    [ ! -f "$PIDFILE" ] && return
+    if running ; then
+        kill -15 $pid
+        # Is it really dead?
+        [ -n "$DODTIME" ] && sleep "$DODTIME"s
+        if running ; then
+            kill -9 $pid
+            [ -n "$DODTIME" ] && sleep "$DODTIME"s
+            if running ; then
+                echo "Cannot kill $NAME (pid=$pid)!"
+                exit 1
+            fi
+        fi
+    fi
+    rm -f $PIDFILE
+    return 0
+}
+
+case "$1" in
+  start)
+  echo -n "Starting $DESC: "
+  if running ; then
+    echo "already running."
+  else
+    $DAEMON $DAEMON_OPTS start
+    # Needed to let Thin handle stale pid file.
+    sleep 1
+    if running ; then
+        echo "OK."
+    else
+        echo "ERROR."
+    fi
+  fi
+  ;;
+  stop)
+  echo -n "Stopping $DESC: "
+  $DAEMON $DAEMON_OPTS stop
+  echo "OK."
+  ;;
+  force-stop)
+  echo -n "Forcefully stopping $DESC: "
+    force_stop
+    if ! running ; then
+        echo "OK."
+    else
+        echo "ERROR."
+    fi
+  ;;
+  #reload)
+  #
+  # If the daemon can reload its config files on the fly
+  # for example by sending it SIGHUP, do it here.
+  #
+  # If the daemon responds to changes in its config file
+  # directly anyway, make this a do-nothing entry.
+  #
+  # echo "Reloading $DESC configuration files."
+  # start-stop-daemon --stop --signal 1 --quiet --pidfile \
+  # /var/run/$NAME.pid --exec $DAEMON
+  #;;
+  force-reload)
+  #
+  # If the "reload" option is implemented, move the "force-reload"
+  # option to the "reload" entry above. If not, "force-reload" is
+  # just the same as "restart" except that it does nothing if the
+  #   daemon isn't already running.
+  # check wether $DAEMON is running. If so, restart
+    if running ;  then
+      $0 restart
+    fi
+  ;;
+  restart)
+    echo "Restarting $DESC..."
+    $0 stop && $0 start
+  ;;
+  status)
+    echo -n "$NAME is "
+    if running ;  then
+      echo "running."
+    else
+      echo "not running."
+      exit 1
+    fi
+    ;;
+  *)
+  N=/etc/init.d/$NAME
+  # echo "Usage: $N {start|stop|restart|reload|force-reload}" >&2
+  echo "Usage: $N {start|stop|restart|force-reload|status|force-stop}" >&2
+  exit 1
+  ;;
+esac
+
+exit 0

data/lib/pkgr/data/debian/install.erb

@@ -0,0 +1,16 @@
+<% config_files.each do |file| %>
+config/<%= file %> etc/<%= name %>
+<% end %>
+config <%= pkg_prefix %>/<%= name %>
+.bundle <%= pkg_prefix %>/<%= name %>
+Gemfile <%= pkg_prefix %>/<%= name %>
+Gemfile.lock <%= pkg_prefix %>/<%= name %>
+config.ru <%= pkg_prefix %>/<%= name %>
+Rakefile <%= pkg_prefix %>/<%= name %>
+app <%= pkg_prefix %>/<%= name %>
+bin <%= pkg_prefix %>/<%= name %>
+db/* var/db/<%= name %>
+lib <%= pkg_prefix %>/<%= name %>
+public <%= pkg_prefix %>/<%= name %>
+script <%= pkg_prefix %>/<%= name %>
+vendor <%= pkg_prefix %>/<%= name %>

data/lib/pkgr/data/debian/links.erb

@@ -0,0 +1,5 @@
+<% config_files.each do |file| %>
+etc/<%= name %>/<%= file %> <%= pkg_prefix %>/<%= name %>/config/<%= file %>
+<% end %>
+var/log/<%= name %> <%= pkg_prefix %>/<%= name %>/log
+var/db/<%= name %> <%= pkg_prefix %>/<%= name %>/db

data/lib/pkgr/data/debian/logrotate.erb

@@ -0,0 +1,10 @@
+# <%= name %> logs:
+/var/log/<%= name %>/*.log {
+  daily
+  missingok
+  rotate 14
+  compress
+  delaycompress
+  notifempty
+  copytruncate
+}

data/lib/pkgr/data/debian/postinst.erb

@@ -0,0 +1,59 @@
+#!/bin/sh
+# postinst script for $NAME
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <postinst> `configure' <most-recently-configured-version>
+#        * <old-postinst> `abort-upgrade' <new version>
+#        * <conflictor's-postinst> `abort-remove' `in-favour' <package>
+#          <new-version>
+#        * <postinst> `abort-remove'
+#        * <deconfigured's-postinst> `abort-deconfigure' `in-favour'
+#          <failed-install-package> <version> `removing'
+#          <conflicting-package> <version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+NAME="<%= name %>"
+PREFIX="<%= prefix %>"
+USER="<%= user %>"
+GROUP="<%= group %>"
+
+case "$1" in
+    configure)
+
+        if [ ! -f $PREFIX/$NAME/bin/$NAME.rb ]; then 
+          mv $PREFIX/$NAME/bin/$NAME $PREFIX/$NAME/bin/$NAME.rb
+        fi
+        echo "#!/usr/bin/ruby1.9.1
+        require '$PREFIX/$NAME/bin/$NAME'
+        " > /usr/bin/$NAME && chmod a+x /usr/bin/$NAME
+        # Creating the user if it does not exist
+        if ! getent passwd $USER > /dev/null; then
+          adduser --no-create-home --system --group $GROUP
+        fi
+        chown -R $USER.$GROUP /etc/$NAME/
+        chown -R $USER.$GROUP /var/db/$NAME/
+        chown -R $USER.$GROUP /var/log/$NAME/
+    ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
+
+

data/lib/pkgr/data/debian/prerm.erb

@@ -0,0 +1,57 @@
+#!/bin/sh
+# prerm script for $NAME
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <prerm> `remove'
+#        * <old-prerm> `upgrade' <new-version>
+#        * <new-prerm> `failed-upgrade' <old-version>
+#        * <conflictor's-prerm> `remove' `in-favour' <package> <new-version>
+#        * <deconfigured's-prerm> `deconfigure' `in-favour'
+#          <package-being-installed> <version> `removing'
+#          <conflicting-package> <version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+NAME="<%= name %>"
+PREFIX="<%= prefix %>"
+USER="<%= user %>"
+GROUP="<%= group %>"
+
+cleanup()
+{
+  /etc/init.d/$NAME stop || true
+  rm /usr/bin/$NAME
+  mv $PREFIX/$NAME/bin/$NAME.rb $PREFIX/$NAME/bin/$NAME
+  return 0;
+}
+
+case "$1" in
+    remove)
+        cleanup
+        deluser $USER || true
+    ;;
+    upgrade|deconfigure)
+        cleanup
+    ;;
+
+    failed-upgrade)
+    ;;
+
+    *)
+        echo "prerm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
+
+

data/lib/pkgr/data/debian/rules.erb

@@ -0,0 +1,7 @@
+#!/usr/bin/make -f
+
+export DH_VERBOSE=1
+
+
+%:
+	dh $@

data/lib/pkgr/data/pkgr.yml

@@ -0,0 +1,31 @@
+version: 0.0.0
+name: 
+description:
+# The git reference from which to build the package:
+git_ref: HEAD
+# The list of configuration files taht you want to see in /etc/{{name}}/
+config_files:
+  - pkgr.yml
+  - database.yml
+# The target architecture of the server on which your app will be built (must
+# be the same as the one on which it is deployed):
+architecture: amd64
+# The list of dependencies required for your app to correctly run:
+debian_runtime_dependencies:
+  - ${shlibs:Depends}
+  - ${misc:Depends}
+  - ruby1.9.1-full
+  - git-core
+  - libxml2
+  - libxslt1.1
+# The list of dependencies required for your app to be packaged (i.e.
+# dependencies of your app's gems + dependencies required to build the
+# package):
+debian_build_dependencies:
+  - debhelper (>= 7)
+  - dpkg-dev
+  - libmysqlclient15-dev
+  - libxml2-dev
+  - libxslt-dev
+  - libsqlite3-dev
+  

data/lib/pkgr/pkgr.rake

@@ -0,0 +1,42 @@
+# ROOT=. rake -I lib -f lib/pkgr/pkgr.rake pkgr:setup
+
+require 'pkgr'
+require 'fileutils'
+
+ROOT = ENV.fetch('ROOT') { Rails.root }
+CONFIG = ENV.fetch('CONFIG') { File.join(ROOT, "config/pkgr.yml") }
+if File.exist?(CONFIG)
+  APP = Pkgr::App.new ROOT, CONFIG
+  APP.valid? || fail("There is an issue with the app you're trying to package: #{APP.errors.join(", ")}")
+end
+
+namespace :pkgr do
+
+  desc "Setup the required files for pkgr"
+  task :setup do
+    Pkgr.setup(ROOT)
+  end
+
+  if defined?(APP)
+    task :generate do
+      APP.generate_required_files
+    end
+
+    namespace :bump do
+      %w{patch minor major}.each do |version|
+        desc "Increments the #{version} version by one"
+        task version.to_sym do
+          APP.bump!(version.to_sym)
+        end
+      end
+    end
+
+    namespace :build do
+      desc "Builds the debian package"
+      task :deb do
+        build_host = ENV.fetch('HOST') { 'localhost' }
+        APP.build_debian_package(build_host)
+      end
+    end
+  end
+end

data/lib/pkgr/railtie.rb

@@ -0,0 +1,7 @@
+module Pkgr
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path("../pkgr.rake", __FILE__)
+    end
+  end
+end

data/lib/pkgr/version.rb

@@ -0,0 +1,3 @@
+module Pkgr
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: pkgr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Cyril Rohr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Package your Rails apps as debian packages
+email:
+- cyril.rohr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- lib/pkgr/app.rb
+- lib/pkgr/data/bin/executable
+- lib/pkgr/data/config/pre_boot.rb
+- lib/pkgr/data/debian/changelog
+- lib/pkgr/data/debian/compat.erb
+- lib/pkgr/data/debian/control.erb
+- lib/pkgr/data/debian/copyright.erb
+- lib/pkgr/data/debian/cron.d
+- lib/pkgr/data/debian/default.erb
+- lib/pkgr/data/debian/dirs.erb
+- lib/pkgr/data/debian/docs.erb
+- lib/pkgr/data/debian/init.d.erb
+- lib/pkgr/data/debian/install.erb
+- lib/pkgr/data/debian/links.erb
+- lib/pkgr/data/debian/logrotate.erb
+- lib/pkgr/data/debian/postinst.erb
+- lib/pkgr/data/debian/prerm.erb
+- lib/pkgr/data/debian/rules.erb
+- lib/pkgr/data/pkgr.yml
+- lib/pkgr/pkgr.rake
+- lib/pkgr/railtie.rb
+- lib/pkgr/version.rb
+- lib/pkgr.rb
+- LICENSE
+- README.md
+homepage: http://github.com/crohr/pkgr
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.3'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Package your Rails apps as debian packages
+test_files: []