appserver 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+/appserver.gemspec
+/pkg
+/VERSION

data/README.md

@@ -4,10 +4,10 @@ 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],
+This 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
+applications. Running it automatically in git update hooks provides an
+automatic deployment of applications whenever the repository is updated
 on the server.
 
 Requirements
@@ -26,18 +26,20 @@ Or check out the [repository][repo] on github.
 Setup
 -----
 
+### Initialize an appserver directory
+
 To run applications, you need to initialize an appserver directory first. To
-do so, create an empty directory and run `appserver init` in it.
+do so, run `appserver init`.
 
-    $ mkdir /var/webapps
-    $ cd /var/webapps
-    $ appserver init
+    $ appserver init /var/webapps
 
 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
+customize settings by editing the `appserver.conf.rb` configuration file. **All
 other files are updated automatically and should not be modified manually.**
 
+### Activate generated Nginx configuration
+
 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.
@@ -47,10 +49,12 @@ Reload Nginx to apply the configuration changes.
     ⋮
     http {
       ⋮
-      include /var/www/nginx.conf;
+      include /var/webapps/nginx.conf;
     }
     ⋮
 
+### Activate generated Monit configuration
+
 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.
@@ -60,6 +64,18 @@ configuration changes.
     ⋮
     include /var/webapps/monitrc
 
+### Optional: Activate generated Logrotate configuration
+
+Modify your system's Logrotate configuration (e.g. `/etc/logrotate.conf` on
+Ubuntu) to include the generated `logrotate.conf` at the bottom. Logrotate
+is typically executed from cron, so there's no daemon to reload to apply the
+configuration changes.
+
+*/etc/logrotate.conf:*
+
+    ⋮
+    include /var/webapps/logrotate.conf
+
 Deploying an application
 ------------------------
 
@@ -70,6 +86,11 @@ How it works
 
 to be done...
 
+Security considerations
+-----------------------
+
+to be done...
+
 Author
 ------
 

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'appserver'
+    gem.summary = 'Monit/Nginx/Unicorn application server configurator using deployment via git'
+    gem.description = 'This tool automatically generates server configs for Monit, Nginx and Unicorn to host your Rack-based (Rails) applications. Running it automatically in git update hooks provides an automatic deployment of applications whenever the repository is updated on the server.'
+    gem.email = 'zargony@gmail.com'
+    gem.homepage = 'http://github.com/zargony/appserver'
+    gem.authors = ['Andreas Neuhaus']
+    gem.requirements << 'a server with Monit, Nginx and Git'
+    gem.add_dependency 'unicorn', '~> 0.97'
+    gem.add_dependency 'git', '~> 1.2'
+    gem.add_dependency 'bundler', '>= 0.9.24'
+    gem.has_rdoc = false
+    gem.add_development_dependency 'mocha'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require 'rake/testtask'
+task :default => :test
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/bin/appserver

@@ -9,18 +9,21 @@ 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 'appserver [options] init <path>'
+  opts.separator '  Initializes an appserver directory. Run this command to set up the given'
+  opts.separator '  directory for deploying applications. After this, you can customize'
+  opts.separator "  settings in #{Appserver::ServerDir::CONFIG_FILE_NAME} inside the directory."
+  opts.separator ''
+  opts.separator 'appserver [options] update'
+  opts.separator '  Updates all generated configuration files.'
   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 'NOTE: For all commands (except "init"), you need to be inside an appserver'
+  opts.separator '      directory, or specify an appserver directory using the --dir option.'
   opts.separator ''
   opts.separator 'Options:'
   opts.on '-d', '--dir PATH', 'Change to the given directory before running the command' do |dir|

data/lib/appserver.rb

@@ -1,8 +1,12 @@
 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"
+  ROOT = File.expand_path('..', __FILE__) unless const_defined?(:ROOT)
+  autoload :Utils,        "#{ROOT}/appserver/utils"
+  autoload :Command,      "#{ROOT}/appserver/command"
+  autoload :Configurator, "#{ROOT}/appserver/configurator"
+  autoload :ServerDir,    "#{ROOT}/appserver/server_dir"
+  autoload :App,          "#{ROOT}/appserver/app"
+  autoload :Repository,   "#{ROOT}/appserver/repository"
+  autoload :Monit,        "#{ROOT}/appserver/monit"
+  autoload :Nginx,        "#{ROOT}/appserver/nginx"
+  autoload :Logrotate,    "#{ROOT}/appserver/logrotate"
 end

data/lib/appserver/app.rb

@@ -1,110 +1,151 @@
+require 'etc'
+
 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',
+  class App < Struct.new(:server_dir, :name, :branch, :ruby, :environment, :user, :group, :instances, :preload,
+                         :env_whitelist, :env, :max_cpu_usage, :max_memory_usage, :usage_check_cycles, :http_check_timeout,
+                         :domain, :hostname, :ssl_cert, :ssl_key, :public_dir)
+
+    SETTINGS_DEFAULTS = {
+      :branch => 'master',
+      :ruby => Utils.find_in_path('ruby') || '/usr/bin/ruby',
       :environment => 'production',
-      :instances => 3,
+      :user => nil,
+      :group => nil,
+      :instances => Utils.number_of_cpus || 1,
+      :preload => false,
+      :env_whitelist => [],
+      :env => {},
       :max_cpu_usage => nil,
       :max_memory_usage => nil,
       :usage_check_cycles => 5,
       :http_check_timeout => 30,
-      :hostname => `/bin/hostname -f`.chomp.gsub(/^[^.]+\./, ''),
+      :domain => Utils.system_domainname,
+      :hostname => nil,
+      :ssl_cert => nil,
+      :ssl_key => nil,
       :public_dir => 'public',
     }
 
-    def self.unicorn_config
-      File.expand_path('../unicorn.conf.rb', __FILE__)
+    SETTINGS_EXPAND = [ :ssl_cert, :ssl_key ]
+
+    ALWAYS_WHITELIST = ['PATH', 'PWD', 'GEM_HOME', 'GEM_PATH', 'RACK_ENV']
+
+    def initialize (server_dir, name, config)
+      self.server_dir, self.name = server_dir, name
+      # Apply configuration settings
+      config.apply!(self, name)
+      # Use the directory owner as the user to run instances under by default
+      self.user ||= exist? ? Etc.getpwuid(File.stat(path).uid).name : 'www-data'
+      # Use a subdomain if no hostname was given specifically for this app
+      self.hostname ||= "#{name.gsub(/[^a-z0-9_-]+/i, '_')}.#{domain}"
     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]
+    def path
+      File.join(server_dir.apps_path, name)
+    end
+
+    def exist?
+      File.directory?(path)
     end
 
-    def dir
-      File.join(server.dir, name)
+    def revision_file
+      File.join(path, 'REVISION')
+    end
+
+    def ssl?
+      ssl_cert && ssl_key
+    end
+
+    def public_path
+      File.expand_path(public_dir, path)
     end
 
     def rack_config
-      File.join(dir, 'config.ru')
+      File.join(path, 'config.ru')
     end
 
     def rack?
       File.exist?(rack_config)
     end
 
+    def unicorn_config
+      File.expand_path('../unicorn.conf.rb', __FILE__)
+    end
+
+    def gem_file
+      File.join(path, 'Gemfile')
+    end
+
+    def bundle_path
+      File.join(path, '.bundle')
+    end
+
     def pid_file
-      File.join(server.tmp_dir, "#{name}.pid")
+      File.join(server_dir.tmp_path, "#{name}.pid")
     end
 
     def socket
-      File.join(server.tmp_dir, "#{name}.socket")
+      File.join(server_dir.tmp_path, "#{name}.socket")
     end
 
     def server_log
-      File.join(server.log_dir, "#{name}.server.log")
+      File.join(server_dir.log_path, "#{name}.server.log")
     end
 
     def access_log
-      File.join(server.log_dir, "#{name}.access.log")
+      File.join(server_dir.log_path, "#{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})
+    def setup_env!
+      # Apply whitelist if set
+      if env_whitelist != '*' && env_whitelist != ['*']
+        ENV.reject! { |key, value| !env_whitelist.include?(key) && !ALWAYS_WHITELIST.include?(key) }
+      end
+      # Set environment variables
+      if env
+        ENV.update(env)
+      end
+      # Setup gem bundle if present
+      if File.exist?(gem_file) && File.directory?(bundle_path)
+        ENV.update({ 'GEM_HOME' => bundle_path, 'BUNDLE_PATH' => bundle_path })
+        # Remember load paths of required gems (which use autloading), before bundler takes away the load path
+        remember_paths = $LOAD_PATH.select { |path| path =~ %r(/(unicorn|rack|appserver)[^/]*/) }
+        # Load bundler and setup gem bundle
+        require 'bundler'
+        Bundler.setup
+        # Re-add remembered load paths
+        $LOAD_PATH.unshift *remember_paths
       end
     end
 
-    def write_nginx_config (f)
-      f.puts ""
-      f.puts "# Application: #{name}"
+    def start_server_cmd
       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 "}"
+        "#{ruby} -S -- unicorn -E #{environment} -Dc #{unicorn_config} #{rack_config}"
       end
     end
 
-  protected
+    def start_server?
+      !!start_server_cmd
+    end
+
+    def start_server
+      exec start_server_cmd if start_server?
+    end
+
+    def server_pid
+      File.readlines(pid_file)[0].to_i rescue nil
+    end
+
+    def stop_server
+      Process.kill(:TERM, server_pid)
+    end
+
+    def restart_server
+      Process.kill(:USR2, server_pid)
+    end
 
-    def expand_path (path)
-      File.expand_path(path, dir)
+    def reopen_server_log
+      Process.kill(:USR1, server_pid)
     end
   end
 end

data/lib/appserver/appserver.conf.rb

@@ -0,0 +1,126 @@
+# 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/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'
+
+# Command to execute to tell Nginx to reopen the log files. Used within
+# the Logrotate snippet, so this command will be called as root
+#nginx_reopen '/usr/sbin/nginx -s reopen'
+
+# Path/name of the logrotate configuration snippet that should be written
+#logrotate_conf 'logrotate.conf'
+
+
+#
+# APPLICATION SETTINGS
+# Can be either specified globally for all applications or application-
+# specific in an "app" block (see examples at the bottom of this file).
+# Paths are relative to the respective directory of the application
+#
+
+# Branch to check out when deploying an application. Defaults to 'master'
+#branch 'master'
+
+# Name/path of the command to call Ruby. By default, this points to the
+# ruby command in your PATH, usually /usr/bin/ruby. Set this, if you want
+# to use a manually installed ruby that is not in your PATH. If you're using
+# RVM, you can use "/usr/local/bin/rvm XYZ ruby" here to easily use
+# different Ruby versions for different applications. Make sure the
+# targetted Ruby version also has the appserver gem installed!
+#ruby '/usr/bin/ruby'
+
+# Rack environment to run the application in. Defaults to 'production'
+#environment 'production'
+
+# User and group to run the instance server under. If user is left empty, the
+# user who owns the application directory is used. If group is left empty, the
+# primary group of the user is used. For security reasons, you might want to
+# set this to a different user than the file owner. (Debian based systems
+# typically use "www-data"). Using root here would be a real bad idea
+#user 'www-data'
+#group 'www-data'
+
+# Number of instances (unicorn workers) for an application. This defaults to
+# the number of CPUs detected, which should be fine for most cases (read the
+# unicorn tuning tips before changing this)
+#instances 2
+
+# Use Unicorn's application preloading before forking instances. Defaults to
+# false (preloading disabled)
+#preload false
+
+# By default, only PATH, PWD, GEM_HOME and GEM_PATH environment settings are
+# preserved. If you need more environment variables to be preserved, add them
+# here. If you set this to '*', all environment variables are preserved
+#env_whitelist [ 'SOME_VAR', 'SOME_OTHER_VAR' ]
+
+# In addition to the whitelisted environment variables, RACK_ENV and
+# BUNDLE_PATH are set. If want to set more environment variables, specify
+# them here
+#env { 'KEY' => 'value' }
+
+# Let Monit watch the CPU usage of instances and restart them if their
+# CPU usage exceeds this value
+#max_cpu_usage '80%'
+
+# Let Monit watch the memory usage of instances and restart them if their
+# memory usage exceeds this value
+#max_memory_usage '100Mb'
+
+# 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 domain will be used as the base domain for applications which you
+# don't specifically set a hostname for. For these applications, a
+# hostname of "<appname>.<domain>" will be set automatically. The hostname
+# tells Nginx, which requests to route to the application and therefore
+# makes it possible to run multiple domains on a single IP address. The
+# domain setting defaults to the system's domainname
+#domain 'example.com'
+
+# If a SSL certificate and key are set, Nginx will be configured to accept
+# HTTPS connections as well. The default is to only accept HTTP
+#ssl_cert '/etc/ssl/certs/mydomain.pem'
+#ssl_key '/etc/ssl/private/mydomain.key'
+
+# Path where public static files should be served from by Nginx. Defaults to
+# the public directory in the application
+#public_dir 'public'
+
+
+#
+# APPLICATIONS
+# All application default settings from above can be overridden for specific
+# applications. You most probably want to set "hostname" to your liking here.
+# Most other settings should do well with their defaults in most cases.
+#
+
+# A simple blog application named "myblog"
+#app 'myblog' do
+#  hostname 'blog.example.com'
+#  instances 1
+#end