appserver 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Andreas Neuhaus
+
+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,83 @@
+Automagic application server configurator
+=========================================
+
+Monit/Nginx/Unicorn application server configurator using deployment via git
+(simply git push applications to your server to deploy them).
+
+This little tool automatically generates server configs for [Monit][monit],
+[Nginx][nginx] and [Unicorn][unicorn] to host your [Rack][rack]-based (Rails)
+applications. Running it automatically in git post-receive hooks provides
+an automatic deployment of applications whenever the repository is updated
+on the server.
+
+Requirements
+------------
+
+A server running [Monit][monit], [Nginx][nginx] and having [Git][git] and
+Ruby with RubyGems installed.
+
+Install
+-------
+
+    gem install appserver
+
+Or check out the [repository][repo] on github.
+
+Setup
+-----
+
+To run applications, you need to initialize an appserver directory first. To
+do so, create an empty directory and run `appserver init` in it.
+
+    $ mkdir /var/webapps
+    $ cd /var/webapps
+    $ appserver init
+
+An appserver directory holds configuration files and everything needed to run
+multiple applications (application code, temp files, log files, ...). You can
+customize settings by editing the `appserver.yml` configuration file. **All
+other files are updated automatically and should not be modified manually.**
+
+Modify your system's Nginx configuration (e.g. `/etc/nginx/nginx.conf` on
+Ubuntu) to include the generated `nginx.conf` **inside a `http` statement**.
+Reload Nginx to apply the configuration changes.
+
+*/etc/nginx/nginx.conf:*
+
+    ⋮
+    http {
+      ⋮
+      include /var/www/nginx.conf;
+    }
+    ⋮
+
+Modify your system's Monit configuration (e.g. `/etc/monit/monitrc` on Ubuntu)
+to include the generated `monitrc` at the bottom. Reload Monit to apply the
+configuration changes.
+
+*/etc/monit/monitrc:*
+
+    ⋮
+    include /var/webapps/monitrc
+
+Deploying an application
+------------------------
+
+to be done...
+
+How it works
+------------
+
+to be done...
+
+Author
+------
+
+Andreas Neuhaus :: <http://zargony.com/>
+
+[repo]: http://github.com/zargony/appserver/
+[monit]: http://mmonit.com/monit/
+[nginx]: http://nginx.com/
+[unicorn]: http://unicorn.bogomips.org/
+[git]: http://git-scm.com/
+[rack]: http://rack.rubyforge.org/

data/bin/appserver

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'optparse'
+require 'appserver'
+
+options = {}
+opts = OptionParser.new(nil, 20, '  ') do |opts|
+  opts.banner = 'Usage: appserver [options] init|deploy|update [arguments]'
+  opts.separator ''
+  opts.separator 'appserver [options] init'
+  opts.separator '  Initializes an appserver directory. Run this command once in an empty'
+  opts.separator '  directory to set it up for deploying applications. After this, you can'
+  opts.separator '  customize settings in appserver.yml inside this directory.'
+  opts.separator ''
+  opts.separator 'appserver [options] deploy <git-repository>'
+  opts.separator '  Deploys an application to the appserver directory and updates configurations.'
+  opts.separator '  Additionally, a hook is installed to the git repository, that auto-deploys'
+  opts.separator '  the application from now on, if sombody pushes to it.'
+  opts.separator ''
+  opts.separator 'appserver [options] update'
+  opts.separator '  Updates all generated configuration files.'
+  opts.separator ''
+  opts.separator 'Options:'
+  opts.on '-d', '--dir PATH', 'Change to the given directory before running the command' do |dir|
+    options[:dir] = dir
+  end
+  opts.on '-f', '--force', 'Force command execution even if it will overwrite files' do
+    options[:force] = true
+  end
+  opts.separator ''
+  opts.separator 'Common options:'
+  opts.on '-h', '--help', 'Show this message' do
+    puts opts; exit
+  end
+  opts.separator ''
+  opts.separator 'See http://github.com/zargony/appserver for more information'
+  opts.separator ''
+end
+
+args = opts.parse!
+
+(puts opts; exit) if args.size < 1
+Appserver::Command.run!(args.shift, args, options)

data/lib/appserver.rb

@@ -0,0 +1,8 @@
+module Appserver
+  ROOT = File.expand_path('..', __FILE__)
+  autoload :Utils,      "#{ROOT}/appserver/utils"
+  autoload :Command,    "#{ROOT}/appserver/command"
+  autoload :Server,     "#{ROOT}/appserver/server"
+  autoload :App,        "#{ROOT}/appserver/app"
+  autoload :Repository, "#{ROOT}/appserver/repository"
+end

data/lib/appserver/app.rb

@@ -0,0 +1,110 @@
+module Appserver
+  class App < Struct.new(:server, :name, :unicorn, :environment, :instances,
+                         :max_cpu_usage, :max_memory_usage, :usage_check_cycles,
+                         :http_check_timeout, :hostname, :public_dir)
+    DEFAULTS = {
+      :unicorn => '/usr/local/bin/unicorn',
+      :environment => 'production',
+      :instances => 3,
+      :max_cpu_usage => nil,
+      :max_memory_usage => nil,
+      :usage_check_cycles => 5,
+      :http_check_timeout => 30,
+      :hostname => `/bin/hostname -f`.chomp.gsub(/^[^.]+\./, ''),
+      :public_dir => 'public',
+    }
+
+    def self.unicorn_config
+      File.expand_path('../unicorn.conf.rb', __FILE__)
+    end
+
+    def initialize (server, name, config)
+      super()
+      self.server, self.name = server, name
+      appconfig = (config[:apps] || {})[name.to_sym] || {}
+      DEFAULTS.each do |key, default_value|
+        self[key] = appconfig[key] || config[key] || default_value
+      end
+      # Use a subdomain of the default hostname if no hostname was given specifically for this app
+      self.hostname = "#{name}.#{hostname}" unless appconfig[:hostname]
+    end
+
+    def dir
+      File.join(server.dir, name)
+    end
+
+    def rack_config
+      File.join(dir, 'config.ru')
+    end
+
+    def rack?
+      File.exist?(rack_config)
+    end
+
+    def pid_file
+      File.join(server.tmp_dir, "#{name}.pid")
+    end
+
+    def socket
+      File.join(server.tmp_dir, "#{name}.socket")
+    end
+
+    def server_log
+      File.join(server.log_dir, "#{name}.server.log")
+    end
+
+    def access_log
+      File.join(server.log_dir, "#{name}.access.log")
+    end
+
+    def write_monit_config (f)
+      f.puts %Q()
+      f.puts %Q(# Application: #{name})
+      if rack?
+        cyclecheck = usage_check_cycles > 1 ? " for #{usage_check_cycles} cycles" : ''
+        f.puts %Q(check process #{name} with pidfile #{expand_path(pid_file)})
+        f.puts %Q(  start program = "#{unicorn} -E #{environment} -Dc #{self.class.unicorn_config} #{rack_config}")
+        f.puts %Q(  stop program = "/bin/kill `cat #{expand_path(pid_file)}`")
+        f.puts %Q(  if totalcpu usage > #{max_cpu_usage}#{cyclecheck} then restart) if max_cpu_usage
+        f.puts %Q(  if totalmemory usage > #{max_memory_usage}#{cyclecheck} then restart) if max_memory_usage
+        f.puts %Q(  if failed unixsocket #{expand_path(socket)} protocol http request "/" timeout #{http_check_timeout} seconds then restart) if http_check_timeout > 0
+        f.puts %Q(  if 5 restarts within 5 cycles then timeout)
+        f.puts %Q(  group #{name})
+      end
+    end
+
+    def write_nginx_config (f)
+      f.puts ""
+      f.puts "# Application: #{name}"
+      if rack?
+        f.puts "upstream #{name}_cluster {"
+        f.puts "  server unix:#{expand_path(socket)} fail_timeout=0;"
+        f.puts "}"
+        f.puts "server {"
+        f.puts "  listen 80;"
+        f.puts "  server_name #{hostname};"
+        f.puts "  root #{expand_path(public_dir)};"
+        f.puts "  access_log #{expand_path(access_log)};"
+        f.puts "  location / {"
+        f.puts "    proxy_set_header X-Real-IP $remote_addr;"
+        f.puts "    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;"
+        f.puts "    proxy_set_header Host $http_host;"
+        f.puts "    proxy_redirect off;"
+        # TODO: maintenance mode rewriting
+        f.puts "    try_files $uri/index.html $uri.html $uri @#{name}_cluster;"
+        f.puts "    error_page 500 502 503 504 /500.html;"
+        f.puts "  }"
+        f.puts "  location @#{name}_cluster {"
+        f.puts "    proxy_pass http://#{name}_cluster;"
+        f.puts "  }"
+        f.puts "}"
+      end
+    end
+
+  protected
+
+    def expand_path (path)
+      File.expand_path(path, dir)
+    end
+  end
+end

data/lib/appserver/appserver.yml

@@ -0,0 +1,85 @@
+# This is an appserver directory configuration of the "appserver" gem. Use the
+# "appserver" command or visit http://github.com/zargony/appserver for details
+
+#
+# SERVER SETTINGS
+# Non application specific. Paths are relative to the appserver directory. The
+# appserver directory is the directory, that contains this configuration file.
+#
+
+# Path to the default directory of git repositories that contain the
+# applications to deploy. Defaults to the home directory of the user 'git'
+#repo_dir: /var/git
+
+# Path/name of the Monit configuration snippet that should be written
+#monit_conf: monitrc
+
+# Command to execute to tell Monit to reload the configuration. Used within
+# the Monit snippet, so this command will be called as root
+#monit_reload: /usr/sbin/monit reload
+
+# Path/name of the Nginx configuration snippet that should be written
+#nginx_conf: nginx.conf
+
+# Command to execute to tell Nginx to reload the configuration. Used within
+# the Monit snippet, so this command will be called as root
+#nginx_reload: /usr/sbin/nginx -s reload
+
+
+#
+# APPLICATION SETTINGS
+# Can be either specified globally for all applications or application-
+# specific under the "apps" subtree (see examples at the bottom of this file).
+# Paths are relative to the respective application directory. Every deployed
+# application has it's own directory under the appserver directory.
+#
+
+# Name/path of unicorn
+#unicorn: /usr/local/bin/unicorn
+
+# Environment to run the application in. Defaults to 'production'
+#environment: production
+
+# Default number of application instances (unicorn workers)
+#instances: 3
+
+# Let Monit watch the CPU usage of instances and restart them if their
+# CPU usage exceeds this value
+#max_cpu_usage:
+
+# Let Monit watch the memory usage of instances and restart them if their
+# memory usage exceeds this value
+#max_memory_usage:
+
+# When doing CPU/memory usage checks, only restart an instance if it exceeds
+# a resource for at least this number of Monit cycles
+#usage_check_cycles: 5
+
+# Let Monit check periodically, if instances provide an answer to HTTP
+# requests within the given timeout, or restart them if they don't. Set
+# to 0 to disable
+#http_check_timeout: 30
+
+# The hostname, Nginx should accept requests for. You most porbably want to
+# specify the hostname for every application below. If an application has no
+# hostname set, a subdomain of this default hostname will be used. Defaults
+# to the system's domainname.
+#hostname: example.com
+
+# Path where public static files should be served from. Defaults to the public
+# directory in the application
+#public_dir: public
+
+
+#
+# APPLICATIONS
+# All application default settings from above can be overridden for every
+# application. You most probably want to set "hostname" to your liking here.
+# Most other settings should do well with their defaults in most cases.
+#
+
+#apps:
+#  # A simple blog application named "myblog"
+#  myblog:
+#    hostname: blog.example.com
+#    instances: 1

data/lib/appserver/command.rb

@@ -0,0 +1,43 @@
+module Appserver
+  class UnknownCommandError < RuntimeError; end
+
+  class Command
+    def self.run! (*args)
+      new(*args).run!
+    end
+
+    attr_reader :command, :arguments, :options
+
+    def initialize (command, arguments, options = {})
+      @command, @arguments, @options = command, arguments, options
+    end
+
+    def run!
+      Dir.chdir(options[:dir]) if options[:dir]
+
+      Server.initialize_dir(options) if command == 'init'
+
+      server = Server.new(options)
+
+      case command
+        when 'init'
+          server.write_configs
+          puts 'Initialized appserver directory.'
+          puts 'Wrote Monit and Nginx configuration snippets. Make sure to include them into'
+          puts 'your system\'s Monit and Nginx configuration to become active.'
+
+        when 'deploy'
+          repository = server.repository(arguments[0])
+          # TODO
+          repository.install_hook
+
+        when 'update'
+          server.write_configs
+          puts 'Wrote Monit and Nginx configuration snippets.'
+
+        else
+          raise UnknownCommandError
+      end
+    end
+  end
+end

data/lib/appserver/repository.rb

@@ -0,0 +1,48 @@
+module Appserver
+  class Repository < Struct.new(:server, :dir)
+    class InvalidRepositoryError < RuntimeError; end
+
+    include Utils
+
+    def initialize (server, dir, config)
+      self.server, self.dir = server, dir.chomp('/')
+      raise InvalidRepositoryError unless valid?
+    end
+
+    def name
+      File.basename(dir, '.git')
+    end
+
+    def valid?
+      File.directory?(File.join(dir, 'hooks')) && File.directory?(File.join(dir, 'refs'))
+    end
+
+    def post_receive_hook
+      File.join(dir, 'hooks', 'post-receive')
+    end
+
+    def install_hook
+      deploy_cmd = "#{File.expand_path($0)} -d #{server.dir} deploy #{dir}"
+      puts deploy_cmd
+      if !File.exist?(post_receive_hook) || !File.executable?(post_receive_hook)
+        puts "Installing git post-receive hook to repository #{dir}..."
+        safe_replace_file(post_receive_hook) do |f|
+          f.puts '#!/bin/sh'
+          f.puts deploy_cmd
+          f.chown File.stat(dir).uid, File.stat(dir).gid
+          f.chmod 0755
+        end
+      elsif !File.readlines(post_receive_hook).any? { |line| line =~ /^#{Regexp.escape(deploy_cmd)}/ }
+        puts "Couldn't install post-receive hook. Foreign hook script already present in repository #{dir}!"
+      else
+        #puts "Hook already installed in repository #{dir}"
+      end
+    end
+
+  protected
+
+    def expand_path (path)
+      File.expand_path(path, dir)
+    end
+  end
+end

data/lib/appserver/server.rb

@@ -0,0 +1,136 @@
+require 'etc'
+require 'yaml'
+
+module Appserver
+  class Server < Struct.new(:dir, :repo_dir, :monit_conf, :monit_reload, :nginx_conf, :nginx_reload)
+    class AlreadyInitializedError < RuntimeError; end
+    class DirectoryNotEmptyError < RuntimeError; end
+    class NotInitializedError < RuntimeError; end
+
+    include Utils
+
+    DEFAULTS = {
+      :repo_dir => (Etc.getpwnam('git') rescue {})[:dir],
+      :monit_conf => 'monitrc',
+      :monit_reload => '/usr/sbin/monit reload',
+      :nginx_conf => 'nginx.conf',
+      :nginx_reload => '/usr/sbin/nginx -s reload',
+    }
+
+    def self.config_file_template
+      File.expand_path('../appserver.yml', __FILE__)
+    end
+
+    def self.search_dir (path = Dir.pwd)
+      if File.exist?(File.join(path, 'appserver.yml'))
+        path
+      elsif path =~ %r(/)
+        search_dir(path.sub(%r(/[^/]*$), ''))
+      else
+        nil
+      end
+    end
+
+    def self.initialize_dir (options = {})
+      raise AlreadyInitializedError if search_dir && !options[:force]
+      raise DirectoryNotEmptyError if Dir.glob('*') != [] && !options[:force]
+      safe_replace_file('appserver.yml') do |f|
+        f.puts File.read(config_file_template)
+      end
+      ['tmp', 'log'].each do |dir|
+        Dir.mkdir(dir) if !File.directory?(dir)
+      end
+    end
+
+    def initialize (options = {})
+      super()
+      # Search upwards for the appserver dir
+      self.dir = self.class.search_dir
+      raise NotInitializedError unless dir
+      # Load configuration settings
+      @config = load_config(config_file)
+      DEFAULTS.each do |key, default_value|
+        self[key] = @config[key] || default_value
+      end
+    end
+
+    def config_file
+      File.join(dir, 'appserver.yml')
+    end
+
+    def tmp_dir
+      File.join(dir, 'tmp')
+    end
+
+    def log_dir
+      File.join(dir, 'log')
+    end
+
+    def app (name)
+      @apps ||= {}
+      @apps[name] ||= App.new(self, name, @config)
+    end
+
+    def apps
+      Dir.glob(File.join(dir, '*')).select { |f| File.directory?(f) }.map { |f| File.basename(f) }.map { |name| app(name) }
+    end
+
+    def repository (name_or_path)
+      path = name_or_path =~ %r(/) ? expand_path(name_or_path) : File.expand_path("#{name_or_path}.git", repo_dir)
+      @repositories ||= {}
+      @repositories[path] ||= Repository.new(self, path, @config)
+    end
+
+    def repositories
+      Dir.glob(File.join(repo_dir, '*.git')).select { |f| File.directory?(f) }.map { |path| repository(path) }
+    end
+
+    def write_configs
+      # Write Monit configuration file
+      safe_replace_file(monit_conf) do |f|
+        f.puts %Q(# Monit configuration automagically generated by the "appserver" gem using)
+        f.puts %Q(# the appserver directory config #{expand_path(config_file)})
+        f.puts %Q(# Include this file into your system's monitrc (using an include statement))
+        f.puts %Q(# to use it. See http://github.com/zargony/appserver for details.)
+        # Let Monit reload itself if this configuration changes
+        f.puts %Q(check file monit_conf with path #{expand_path(monit_conf)})
+        f.puts %Q(  if changed checksum then exec "#{monit_reload}")
+        # Reload Nginx if its configuration changes
+        f.puts %Q(check file nginx_conf with path #{expand_path(nginx_conf)})
+        f.puts %Q(  if changed checksum then exec "#{nginx_reload}")
+        # Add application-specific Monit configuration
+        apps.each do |app|
+          app.write_monit_config(f)
+        end
+      end
+      # Write Nginx configuration file
+      safe_replace_file(nginx_conf) do |f|
+        f.puts %Q(# Nginx configuration automagically generated by the "appserver" gem using)
+        f.puts %Q(# the appserver directory config #{expand_path(config_file)})
+        f.puts %Q(# Include this file into your system's nginx.conf \(using an include statement)
+        f.puts %Q(# inside a http statement\) to use it. See http://github.com/zargony/appserver)
+        f.puts %Q(# for details.)
+        # The default server always responds with 403 Forbidden
+        f.puts %Q(server {)
+        f.puts %Q(  listen 80 default;)
+        f.puts %Q(  server_name _;)
+        f.puts %Q(  deny all;)
+        f.puts %Q(})
+        # Add application-specific Nginx configuration
+        apps.each do |app|
+          app.write_nginx_config(f)
+        end
+      end
+    end
+
+  protected
+
+    def expand_path (path)
+      File.expand_path(path, dir)
+    end
+
+    def load_config (filename)
+      symbolize_keys(YAML.load_file(filename) || {})
+    end
+  end
+end

data/lib/appserver/unicorn.conf.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../appserver', __FILE__)
+# We assume that the last argument to unicorn is the full path to config.ru
+Dir.chdir(File.expand_path('..', Unicorn::HttpServer::START_CTX[:argv][-1]))
+app = Appserver::Server.new.app(File.basename(Dir.pwd))
+
+working_directory app.dir
+stderr_path app.server_log
+stdout_path app.server_log
+puts "Appserver unicorn configuration for #{app.dir}"
+pid app.pid_file
+listen "unix:#{app.socket}", :backlog => 64
+#user 'user', 'group'
+worker_processes app.instances
+timeout 30
+preload_app true
+
+# Use COW-friendly REE for memory saving, especially with preloaded apps
+# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+
+before_fork do |server, worker|
+  # For preloaded apps, it is highly recommended to disconnect any database
+  # connection and reconnect it in the worker
+  if server.config[:preload_app]
+    ActiveRecord::Base.connection.disconnect! if defined?(ActiveRecord::Base)
+  end
+
+  # The following is only recommended for memory/DB-constrained
+  # installations.  It is not needed if your system can house
+  # twice as many worker_processes as you have configured.
+  #
+  # # This allows a new master process to incrementally
+  # # phase out the old master process with SIGTTOU to avoid a
+  # # thundering herd (especially in the "preload_app false" case)
+  # # when doing a transparent upgrade.  The last worker spawned
+  # # will then kill off the old master process with a SIGQUIT.
+  # old_pid = "#{server.config[:pid]}.oldbin"
+  # if old_pid != server.pid
+  #   begin
+  #     sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+  #     Process.kill(sig, File.read(old_pid).to_i)
+  #   rescue Errno::ENOENT, Errno::ESRCH
+  #   end
+  # end
+  #
+  # # *optionally* throttle the master from forking too quickly by sleeping
+  # sleep 1
+end
+
+after_fork do |server, worker|
+  # Per-process listener ports for debugging/admin/migrations
+  #addr = "127.0.0.1:#{9293 + worker.nr}"
+  #server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
+
+  # Reconnect the database connection in the worker (see disconnect above)
+  if server.config[:preload_app]
+    ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+    # TODO: check for other database mapper and reconnect them (mongo, memcache, redis)
+  end
+end

data/lib/appserver/utils.rb

@@ -0,0 +1,34 @@
+require 'tempfile'
+
+module Appserver
+  module Utils
+    def self.included (base)
+      base.class_eval do
+        extend Methods
+        include Methods
+      end
+    end
+
+    module Methods
+      def safe_replace_file (filename)
+        tempfile = Tempfile.new(File.basename(filename) + '.', File.dirname(filename))
+        if File.exist?(filename)
+          tempfile.chown(File.stat(filename).uid, File.stat(filename).gid)
+          tempfile.chmod(File.stat(filename).mode)
+        end
+        yield tempfile
+        tempfile.close
+        File.unlink(filename) if File.exist?(filename)
+        File.rename(tempfile, filename)
+      end
+
+      def symbolize_keys (hash)
+        hash.inject({}) do |memo, (key, value)|
+          value = symbolize_keys(value) if Hash === value
+          memo[key.to_sym] = value
+          memo
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: appserver
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andreas Neuhaus
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-28 00:00:00 +02:00
+default_executable: appserver
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: unicorn
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 97
+        version: "0.97"
+  type: :runtime
+  version_requirements: *id001
+description: This little tool automatically generates server configs for Monit, Nginx and Unicorn to host your Rack-based (Rails) applications. Running it automatically in git post-receive hooks provides an automatic deployment of applications whenever the repository is updated on the server.
+email: zargony@gmail.com
+executables: 
+- appserver
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- bin/appserver
+- lib/appserver.rb
+- lib/appserver/app.rb
+- lib/appserver/appserver.yml
+- lib/appserver/command.rb
+- lib/appserver/repository.rb
+- lib/appserver/server.rb
+- lib/appserver/unicorn.conf.rb
+- lib/appserver/utils.rb
+has_rdoc: true
+homepage: http://github.com/zargony/appserver
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- nginx v0.7.x or greater
+- monit v5.x or greater
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Monit/nginx/unicorn application server configurator using deployment via git
+test_files: []
+