sunshine 1.0.0.pre

data/lib/sunshine/daemons/nginx.rb

@@ -0,0 +1,104 @@
+module Sunshine
+
+  ##
+  # Simple server wrapper for nginx setup and control.
+
+  class Nginx < Server
+
+    def initialize app, options={}
+      super
+
+      @sudo ||= @port < 1024
+
+      @dep_name = use_passenger? ? 'passenger-nginx' : 'nginx'
+    end
+
+
+    def start_cmd
+      "#{@bin} -c #{self.config_file_path}"
+    end
+
+
+    def stop_cmd
+      cmd = "test -f #{@pid} && kill -QUIT $(cat #{@pid})"+
+        " || echo 'No #{@name} process to stop for #{@app.name}';"
+      cmd << "sleep 2 ; rm -f #{@pid};"
+    end
+
+
+    def setup
+      super do |server_app, binder|
+
+        binder.forward :use_passenger?
+
+        binder.set :passenger_root do
+          passenger_root server_app.shell
+        end
+
+        binder.set :nginx_conf_path do
+          nginx_bin = server_app.shell.call "which nginx"
+          File.join File.dirname(nginx_bin), '..', 'conf'
+        end
+
+        yield(server_app, binder) if block_given?
+      end
+    end
+
+
+    ##
+    # Check if passenger is required to run the application.
+    # Returns true if the server's target is a Sunshine::App
+
+    def use_passenger?
+      Sunshine::App === @target
+    end
+
+
+    ##
+    # Gets the root of the installer passenger gem.
+
+    def passenger_root shell
+      str     = shell.call "gem list passenger -d"
+      version = $1 if str =~ /passenger\s\((.*)\)$/
+      gempath = $1 if str =~ /Installed\sat:\s(.*)$/
+
+      return unless version && gempath
+
+      File.join(gempath, "gems/passenger-#{version}")
+    end
+
+
+    ##
+    # Run passenger installation for nginx
+
+    def setup_passenger server_app
+      server_app.install_deps 'passenger'
+
+      server_app.shell.call \
+        'passenger-install-nginx-module --auto --auto-download',
+                                        :sudo => true do |stream, data, inn|
+
+        if data =~ /Please specify a prefix directory \[(.*)\]:/
+
+          dir = $1
+          inn.puts dir
+
+          required_dirs = [
+            File.join(dir, 'fastcgi_temp'),
+            File.join(dir, 'proxy_temp')
+          ]
+
+          server_app.shell.call \
+            "mkdir -p #{required_dirs.join(" ")}", :sudo => true
+
+          error_log = File.join(dir, "logs/error.log")
+
+          server_app.shell.call \
+            "touch #{error_log} && chmod a+rw #{error_log}", :sudo => true
+
+          server_app.add_shell_paths File.join(dir, 'sbin')
+        end
+      end
+    end
+  end
+end

data/lib/sunshine/daemons/rainbows.rb

@@ -0,0 +1,35 @@
+module Sunshine
+
+  ##
+  # Simple server wrapper for Rainbows setup and control.
+
+  class Rainbows < Unicorn
+
+    attr_reader :concurrency
+
+    ##
+    # Assign and/or use a concurrency model. Supports all Rainbows concurrency
+    # models; defaults to :ThreadSpawn
+    # Allows options:
+    # :model:: :ConcurrModel - concurrency model. Defaults to ThreadSpawn
+    # :connections:: int - the number of worker connections to use.
+    # :timeout:: seconds - the keepalive timeout. zero disables keepalives.
+
+    def use_concurrency options=nil
+      @concurrency ||= {:model => :ThreadSpawn}
+      @concurrency.merge! options
+    end
+
+
+    ##
+    # Setup Rainbows specific bindings before building its config.
+
+    def setup
+      super do |server_app, binder|
+        binder.forward :concurrency
+
+        yield(server_app, binder) if block_given?
+      end
+    end
+  end
+end

data/lib/sunshine/daemons/server.rb

@@ -0,0 +1,66 @@
+module Sunshine
+
+  ##
+  # An abstract class to wrap simple server software setup and start/stop.
+  #
+  # Child classes are expected to at least provide a start and stop bash script
+  # by either overloading the start_cmd and stop_cmd methods, or by setting
+  # @start_cmd and @stop_cmd. A restart_cmd method or @restart_cmd attribute
+  # may also be specified if restart requires more functionality than simply
+  # calling start_cmd && stop_cmd.
+
+  class Server < Daemon
+
+    def self.binder_methods
+      [:server_name, :port].concat super
+    end
+
+
+    attr_reader :server_name, :port
+
+
+    # Server objects need only an App object to be instantiated.
+    # All Daemon init options are supported plus the following:
+    #
+    # :port:: port_num - the port to run the server on
+    #                    defaults to 80
+    #
+    # :server_name:: myserver.com - host name used by server
+    #                               defaults to nil
+    #
+    # By default, servers also assign the option :role => :web.
+
+    def initialize app, options={}
+      options[:role] ||= :web
+
+      super app, options
+
+      @port        = options[:port] || 80
+      @server_name = options[:server_name]
+    end
+
+
+    private
+
+    def config_binding shell
+      binder = super
+
+      binder.set :server_name, (@server_name || shell.host)
+
+      binder
+    end
+
+
+    def register_after_user_script
+      super
+
+      @app.after_user_script do |app|
+        next unless @port
+
+        each_server_app do |sa|
+          sa.info[:ports][@pid] = @port
+        end
+      end
+    end
+  end
+end

data/lib/sunshine/daemons/unicorn.rb

@@ -0,0 +1,26 @@
+module Sunshine
+
+  ##
+  # Simple server wrapper for Unicorn setup and control.
+
+  class Unicorn < Server
+
+    def initialize app, options={}
+      super
+      @timeout = options[:timeout] || 3.0
+    end
+
+
+    def start_cmd
+      "cd #{@app.current_path} && #{@bin} -D -E"+
+        " #{@app.deploy_env} -p #{@port} -c #{self.config_file_path};"
+    end
+
+
+    def stop_cmd
+      "test -f #{@pid} && kill -QUIT $(cat #{@pid})"+
+        " || echo 'No #{@name} process to stop for #{@app.name}';"+
+        "sleep 2; rm -f #{@pid};"
+    end
+  end
+end

data/lib/sunshine/dependencies.rb

@@ -0,0 +1,103 @@
+##
+# Defines Sunshine deploy server dependencies.
+
+#class Sunshine::Dependencies < Settler
+Sunshine.dependencies.instance_eval do
+
+  yum 'tpkg'
+
+  apt 'svn', :pkg => 'subversion'
+  yum 'svn', :pkg => 'subversion'
+
+  apt 'git', :pkg => 'git-core'
+  yum 'git', :pkg => 'git-core'
+
+  apt 'nginx'
+  yum 'nginx'
+
+  apt 'logrotate'
+  yum 'logrotate'
+
+  apt 'ruby', :pkg => 'ruby-full'
+  yum 'ruby'
+
+  apt 'ruby-devel', :pkg => 'ruby-dev'
+  yum 'ruby-devel'
+
+  apt 'irb'
+  yum 'irb', :pkg => 'ruby-irb'
+
+  apt 'rubygems', :version => '1.3.5' do
+    requires 'ruby', 'ruby-devel'
+  end
+  yum 'rubygems', :version => '1.3.5' do
+    requires 'ruby', 'ruby-devel'
+  end
+
+  apt 'logrotate'
+  yum 'logrotate'
+
+  apt 'curl-devel', :pkg => 'libcurl-dev'
+  yum 'curl-devel'
+
+  apt 'libxml2-devel', :pkg => 'libxml2-dev'
+  yum 'libxml2-devel'
+
+  apt 'libxslt-devel', :pkg => 'libxslt-dev'
+  yum 'libxslt-devel'
+
+  apt 'sqlite', :pkg => 'sqlite3'
+  yum 'sqlite'
+
+  apt 'sqlite-devel', :pkg => 'libsqlite3-dev'
+  yum 'sqlite-devel'
+
+
+  # Define gems used by Sunshine
+
+  gem 'bundler', :version => ">=0.9"
+
+  gem 'isolate', :version => ">=1.3.0"
+
+  gem 'rake', :version => ">=0.8"
+
+  gem 'passenger-nginx', :pkg => 'passenger' do
+    install do |shell, sudo|
+
+      shell.call "gem install passenger --no-ri --no-rdoc", :sudo => sudo
+
+      shell.call 'passenger-install-nginx-module --auto --auto-download',
+                                        :sudo => true do |stream, data, inn|
+
+        if data =~ /Please specify a prefix directory \[(.*)\]:/
+
+          dir = $1
+          inn.puts dir
+
+          required_dirs = [
+            File.join(dir, 'fastcgi_temp'),
+            File.join(dir, 'proxy_temp')
+          ]
+
+          shell.call "mkdir -p #{required_dirs.join(" ")}", :sudo => true
+
+          err_log = File.join(dir, "logs/error.log")
+          shell.call "touch #{err_log} && chmod a+rw #{err_log}", :sudo => true
+        end
+      end
+    end
+  end
+
+  gem 'geminstaller', :version => ">=0.5"
+
+  gem 'unicorn', :version => ">=0.9"
+
+  gem 'rainbows', :version => ">=0.90.2"
+
+  gem 'ar_mailer', :version => ">=1.5.0"
+
+  gem 'haml'
+
+  gem 'daemons'
+
+end

data/lib/sunshine/dependency_lib.rb

@@ -0,0 +1,200 @@
+module Sunshine
+
+  ##
+  # DependencyLib is a simple class for building and handling depenedencies.
+  # A dependency tree can be defined by inheriting the DependencyLib class, and
+  # dependencies can be defined through dependency instantiation methods:
+  #
+  #   dependency_lib.instance_eval do
+  #
+  #     yum 'ruby', :pkg => 'ruby-devel'
+  #
+  #     yum 'rubygems', :requires => 'ruby'
+  #
+  #     gem 'rdoc', :requires => 'rubygems'
+  #
+  #     gem 'ri', :requires => 'rubygems'
+  #
+  #   end
+  #
+  # Calling the install for rdoc will then check and install all of its parent
+  # dependencies as well:
+  #
+  #   dependency_lib.install 'rdoc', 'ri'
+  #
+  # Dependencies may also be generic and/or have custom bash scripts
+  # for installs, uninstalls, and presence checks:
+  #
+  #   dependency 'custom' do
+  #     requires  'yum', 'ruby'
+  #     install   'sudo yum install custom'
+  #     uninstall 'sudo yum remove custom'
+  #     check     'yum list installed custom'
+  #   end
+  #
+  # See the Dependency class for more information.
+
+  class DependencyLib
+
+    class MissingDependency < Exception; end
+
+    ##
+    # Array of all dependency classes. Appended to automatically when
+    # DependencyLib::Dependency is inherited.
+
+    def self.dependency_types
+      @dependency_types ||= []
+    end
+
+
+    attr_reader :dependencies
+
+    def initialize
+      @dependencies = Hash.new
+    end
+
+
+    ##
+    # Returns a dependency hash by type:
+    #   DependencyLib['name'] #=> {:yum => <Yum...>, :apt => <Apt...>, ...}
+
+    def [](key)
+      @dependencies[key]
+    end
+
+
+    ##
+    # Add a dependency to the dependencies hash.
+
+    def add dep
+      (@dependencies[dep.name] ||= []).unshift dep
+    end
+
+
+    ##
+    # Checks for the existance of a dependency by name
+
+    def exist? key
+      @dependencies.has_key? key
+    end
+
+
+    ##
+    # Get a dependency object by name. Supports passing :type => :pkg_manager
+    # if dependencies with the same name but different package managers exist:
+    #   dependencies.get 'daemon', :type => Gem
+    #   #=> <Gem @name="daemon"...>
+    #
+    # For an 'nginx' dependency defined for both apt and yum, where the yum
+    # dependency object was added to the tree last. Returns nil if
+    # no matching dependency type is found:
+    #   dependencies.get 'nginx'
+    #   #=> <Yum @name="nginx"...>
+    #
+    #   dependencies.get 'nginx', :type => Apt
+    #   #=> <Apt @name="nginx"...>
+    #
+    # Use the :prefer option if a certain dependency type is prefered but
+    # will fall back to whatever first dependency is available:
+    #   dependencies.yum 'my_dep'
+    #   dependencies.get 'my_dep', :prefer => Apt
+    #   #=> <Yum @name="my_dep"...>
+    #
+    # Both the :type and the :prefer options support passing arrays to search
+    # from best to least acceptable candidate:
+    #   dependencies.yum 'my_dep'
+    #   dependencies.apt 'my_dep'
+    #   dependencies.get 'my_dep', :type => [Tpkg, Yum]
+    #   #=> <Yum @name="my_dep"...>
+
+    def get name, options={}
+      return unless exist? name
+
+      deps      = @dependencies[name]
+      dep_types = [*(options[:type] || options[:prefer])].compact
+
+      return deps.first if dep_types.empty?
+
+      dep_types.each do |dep_type|
+        deps.each do |dep|
+          return dep if dep_type === dep
+        end
+      end
+
+      return deps.first unless options[:type]
+    end
+
+
+    ##
+    # Install one or more dependencies:
+    #
+    #   dependencies.install 'dep1', 'dep2', options_hash
+    #
+    # See DependencyLib#get and Dependency#install! for supported options.
+    #
+    # Note: If a Dependency object is passed and the :type option is set,
+    # DependencyLib will attempt to find and install a dependency of class :type
+    # with the same name as the passed Dependency object:
+    #   my_dep = dependencies.yum "my_dep_yum_only"
+    #   dependencies.install my_dep, :type => Apt
+    #   #=> "No dependency 'my_dep' [Sunshine::Apt]"
+
+    def install(*deps)
+      send_each(:install!, *deps)
+    end
+
+
+    ##
+    # Uninstall one or more dependencies:
+    #
+    #   dependencies.uninstall 'dep1', 'dep2', options_hash
+    #
+    # See DependencyLib#get and Dependency#uninstall! for supported options.
+
+    def uninstall(*deps)
+      send_each(:uninstall!, *deps)
+    end
+
+
+    ##
+    # Get and call method on each dependency passed
+
+    def send_each(method, *deps)
+      options = Hash === deps.last ? deps.delete_at(-1).dup : {}
+
+      #if options[:call].respond_to? :pkg_manager
+      #  options[:prefer] ||= options[:call].pkg_manager
+      #end
+
+      deps.each do |dep_name|
+        dep = if Dependency === dep_name
+                if options[:type] && !(options[:type] === dep_name)
+                  get(dep_name.name, options)
+                else
+                  dep_name
+                end
+              else
+                get(dep_name, options)
+              end
+
+        raise MissingDependency,
+          "No dependency '#{dep_name}' [#{options[:type] || "any"}]" if !dep
+
+        # Remove :type so dependencies of other types than dep can be installed
+        options.delete(:type)
+
+        dep.send method, options
+      end
+    end
+
+
+    ##
+    # Define if sudo should be used
+
+    def self.sudo= value
+      dependency_types.each do |dep_class|
+        dep_class.sudo = value
+      end
+    end
+  end
+end

data/lib/sunshine/exceptions.rb

@@ -0,0 +1,54 @@
+module Sunshine
+
+  ##
+  # A standard sunshine exception
+  class Exception < StandardError
+    def initialize input=nil, message=nil
+      if ::Exception === input
+        message = [message, input.message].compact.join(": ")
+        super(message)
+        self.set_backtrace(input.backtrace)
+      else
+        super(input)
+      end
+    end
+  end
+
+
+  ##
+  # An error occurred when attempting to run a command on the local system
+  class CmdError < Exception; end
+
+
+  ##
+  # An ssh call returned a non-zero exit code
+  class SSHCmdError < CmdError
+    attr_reader :shell
+    def initialize message=nil, shell=nil
+      @shell = shell
+      super(message)
+    end
+  end
+
+
+  ##
+  # Something went wrong with a deploy-specific item.
+  class DeployError < Exception; end
+
+
+  ##
+  # The error is serious enough that deploy cannot proceed.
+  # Sunshine will attempt to revert to a previous deploy if available.
+  class CriticalDeployError < DeployError; end
+
+
+  ##
+  # The error is so serious that all no more action can be taken.
+  # Sunshine will attempt to close any ssh connections and stop the deploy.
+  class FatalDeployError < DeployError; end
+
+  ##
+  # A dependency could not be installed.
+  class DependencyError < FatalDeployError; end
+
+end

data/lib/sunshine/healthcheck.rb

@@ -0,0 +1,83 @@
+module Sunshine
+
+  ##
+  # Healthcheck objects handle enabling and disabling health checking for
+  # load balancers by touching health.enabled and health.disabled files on
+  # an app's shell.
+
+  class Healthcheck
+
+    ENABLED_FILE  = "health.enabled"
+    DISABLED_FILE = "health.disabled"
+
+    attr_accessor :shell, :enabled_file, :disabled_file
+
+    def initialize path, shell
+      @shell = shell
+      @enabled_file  = File.join path, ENABLED_FILE
+      @disabled_file = File.join path, DISABLED_FILE
+    end
+
+
+    ##
+    # Disables healthcheck - status: :disabled
+
+    def disable
+      @shell.call "touch #{@disabled_file} && rm -f #{@enabled_file}"
+    end
+
+
+    ##
+    # Check if healthcheck is disabled.
+
+    def disabled?
+      @shell.file? @disabled_file
+    end
+
+
+    ##
+    # Check if healthcheck is down.
+
+    def down?
+      !@shell.file?(@disabled_file) && !@shell.file?(@enabled_file)
+    end
+
+
+    ##
+    # Enables healthcheck which should set status to :ok
+
+    def enable
+      @shell.call "rm -f #{@disabled_file} && touch #{@enabled_file}"
+    end
+
+
+    ##
+    # Check if healthcheck is enabled.
+
+    def enabled?
+      @shell.file? @enabled_file
+    end
+
+
+    ##
+    # Remove the healthcheck file - status: :down
+
+    def remove
+      @shell.call "rm -f #{@disabled_file} #{@enabled_file}"
+    end
+
+
+    ##
+    # Get the health status from the shell.
+    # Returns one of three states:
+    #   :enabled:   everything is great
+    #   :disabled:  healthcheck was explicitely turned off
+    #   :down:      um, something is wrong
+
+    def status
+      return :disabled if disabled?
+      return :enabled  if enabled?
+      :down
+    end
+  end
+end