sunshine 1.0.0.pre

data/examples/deploy_tasks.rake

@@ -0,0 +1,112 @@
+require 'sunshine'
+
+namespace :sunshine do
+
+  desc "Instantiate Sunshine"
+  task :app do
+    deploy_env = ENV['env'] || ENV['RACK_ENV'] || ENV['RAILS_ENV']
+    deploy_env ||= "development"
+
+    Sunshine.setup 'sudo'          => 'app_user',
+                   'web_directory' => '/var/www',
+                   'deploy_env'    => deploy_env
+
+    app_hash = {
+      :repo => {
+        :type => :svn,
+        :url  => "svn://subversion/path/to/my_app/tags/release001"
+      },
+      :remote_shells => %w{user@my_server.com}
+    }
+
+    @app = Sunshine::App.new app_hash
+  end
+
+
+  desc "Deploy the app"
+  task :deploy => :app do
+    Sunshine.setup 'trace' => true
+
+    @app.deploy do |app|
+
+      rainbows = Sunshine::Rainbows.new(app, :port => 5001)
+
+      nginx = Sunshine::Nginx.new(app, :point_to => rainbows, :port => 5000)
+
+      app.run_geminstaller
+
+      rainbows.setup
+      nginx.setup
+    end
+
+    @app.start :force => true
+  end
+
+
+  # Post-deploy control tasks:
+
+  desc "Run db:migrate on remote :db servers"
+  task :db_migrate => :app do
+    @app.rake 'db:migrate', :role => :db
+  end
+
+
+  desc "Run the remote start script"
+  task :start => :app do
+    @app.start
+    puts @app.status.to_yaml
+  end
+
+
+  desc "Run the remote stop script"
+  task :stop => :app do
+    @app.stop
+    puts @app.status.to_yaml
+  end
+
+
+  desc "Run the remote restart script"
+  task :restart => :app do
+    @app.restart
+    puts @app.status.to_yaml
+  end
+
+
+  desc "Check if the deployed app is running"
+  task :status => :app do
+    puts @app.status.to_yaml
+  end
+
+
+  desc "Get deployed app info"
+  task :info => :app do
+    puts @app.deploy_details.to_yaml
+  end
+
+
+  desc "Get the health state"
+  task :health => :app do
+    puts @app.health.to_yaml
+  end
+
+
+  namespace :health do
+
+    desc "Turn on health check"
+    task :enable => :app do
+      puts @app.health(:enable).to_yaml
+    end
+
+
+    desc "Turn off health check"
+    task :disable => :app do
+      puts @app.health(:disable).to_yaml
+    end
+
+
+    desc "Remove health check"
+    task :remove => :app do
+      puts @app.health(:remove).to_yaml
+    end
+  end
+end

data/examples/standalone_deploy.rb

@@ -0,0 +1,31 @@
+require 'sunshine'
+
+Sunshine.setup 'sudo'          => 'app_user',
+               'trace'         => true,
+               'web_directory' => "/var/www"
+
+##
+# Deploy!
+
+Sunshine::App.deploy :name => 'my_app' do |app|
+
+  rainbows = Sunshine::Rainbows.new(app, :port => 5001)
+
+  nginx = Sunshine::Nginx.new(app, :point_to => rainbows, :port => 5000)
+
+  app.run_geminstaller
+
+  rainbows.restart
+  nginx.restart
+end
+
+
+__END__
+
+:default:
+  :repo:
+    :type: svn
+    :url:  svn://subversion/path/to/<%= name %>/tags/release001
+
+  :remote_shells:
+    - <%= deploy_env %>-<%= name %>.my_server.com

data/lib/commands/add.rb

@@ -0,0 +1,96 @@
+module Sunshine
+
+  ##
+  # Registers a path as a sunshine application for control via sunshine.
+  #
+  # Usage: sunshine add app_path [more paths...] [options]
+  #
+  # Arguments:
+  #     app_path    Path to the application to add.
+  #                 A name may be assigned to the app by specifying name:path.
+  #                 By default: name = File.basename app_path
+  #
+  # Options:
+  #     -f, --format FORMAT        Set the output format (txt, yml, json)
+  #     -u, --user USER            User to use for remote login. Use with -r.
+  #     -r, --remote svr1,svr2     Run on one or more remote servers.
+  #     -v, --verbose              Run in verbose mode.
+
+  class AddCommand < ListCommand
+
+    ##
+    # Takes an array and a hash, runs the command and returns:
+    #   true: success
+    #   false: failed
+    #   exitcode:
+    #     code == 0: success
+    #     code != 0: failed
+    # and optionally an accompanying message.
+
+    def self.exec names, config
+      apps_hash  = parse_app_paths(*names)
+
+      output = exec_each_server config do |shell|
+        server_command = new(shell)
+        results        = server_command.add apps_hash
+
+        self.save_list server_command.app_list, shell
+
+        results
+      end
+
+      return output
+    end
+
+
+    ##
+    # Takes an array of app path definitions and returns a hash:
+    #   parse_app_paths "myapp:/path/to/app", "/path/to/otherapp"
+    #   #=> {'myapp' => '/path/to/app', 'otherapp' => '/path/to/otherapp'}
+
+    def self.parse_app_paths(*app_paths)
+      apps_hash = {}
+      app_paths.each do |path|
+        name, path = path.split(":") if path.include?(":")
+        name ||= File.basename path
+
+        apps_hash[name] = path
+      end
+      apps_hash
+    end
+
+
+    ##
+    # Add a registered app on a given deploy server
+
+    def add apps_hash
+      response_for_each(*apps_hash.keys) do |name|
+        path = apps_hash[name]
+        test_dir = @shell.call("test -d #{path}") rescue false
+
+        raise "'#{path}' is not a directory." unless test_dir
+
+        @app_list[name] = path
+      end
+    end
+
+
+    ##
+    # Parses the argv passed to the command
+
+    def self.parse_args argv
+
+      parse_remote_args(argv) do |opt, options|
+        opt.banner = <<-EOF
+
+Usage: #{opt.program_name} add app_path [more paths...] [options]
+
+Arguments:
+    app_path      Path to the application to add.
+                  A name may be assigned to the app by specifying name:app_path.
+                  By default: name = File.basename app_path
+        EOF
+      end
+    end
+  end
+end

data/lib/commands/default.rb

@@ -0,0 +1,169 @@
+module Sunshine
+
+  ##
+  # Default sunshine behavior when no command is passed. Outputs help.
+
+  class DefaultCommand
+
+    ##
+    # Takes an array and a hash, runs the command and returns:
+    #   true: success
+    #   false: failed
+    #   exitcode:
+    #     code == 0: success
+    #     code != 0: failed
+    # and optionally an accompanying message.
+
+    def self.exec argv, config
+      template_rakefile = "#{Sunshine::ROOT}/templates/tasks/sunshine.rake"
+
+      target_rakefile = config['rakefile']
+
+      FileUtils.cp template_rakefile, target_rakefile
+
+      return true, "Copied Sunshine template rakefile to #{target_rakefile}"
+    end
+
+
+    ##
+    # Base option parser constructor used by all commands.
+
+    def self.opt_parser options=nil
+      OptionParser.new do |opt|
+        opt.program_name = File.basename $0
+        opt.version = Sunshine::VERSION
+        opt.release = nil
+
+        yield opt if block_given?
+
+        opt.on('-S', '--sudo [USER]',
+               'Run remote commands using sudo or sudo -u USER.') do |value|
+          options['sudo'] = value || true
+        end if options
+      end
+    end
+
+
+    ##
+    # Returns the main sunshine help when no arguments are passed.
+
+    def self.parse_args argv
+      options = {}
+
+      opts = opt_parser do |opt|
+        opt.banner = <<-EOF
+
+Sunshine is an object oriented deploy tool for rack applications. 
+
+  Usage:
+    #{opt.program_name} -h/--help
+    #{opt.program_name} -v/--version
+    #{opt.program_name} command [arguments...] [options...]
+
+  Examples:
+    #{opt.program_name} deploy deploy_script.rb
+    #{opt.program_name} restart myapp -r user@server.com,user@host.com
+    #{opt.program_name} list myapp myotherapp --health -r user@server.com
+    #{opt.program_name} list myapp --status
+
+  Commands:
+    add       Register an app with #{opt.program_name}
+    deploy    Run a deploy script
+    list      Display deployed apps
+    restart   Restart a deployed app
+    rm        Unregister an app with #{opt.program_name}
+    start     Start a deployed app
+    stop      Stop a deployed app
+
+   Options:
+        EOF
+
+        opt.on('--rakefile [PATH]',
+               'Copy the Sunshine template rakefile.') do |path|
+          options['rakefile'] = path || File.join(Dir.pwd, "sunshine.rake")
+        end
+
+        opt.separator nil
+        opt.separator "For more help on sunshine commands, "+
+                      "use '#{opt.program_name} COMMAND --help'"
+        opt.separator nil
+      end
+
+
+      opts.parse! argv
+
+      if options.empty?
+        puts opts
+        exit 1
+      end
+
+      options
+    end
+
+
+    ##
+    # Parse arguments for a command that acts remotely.
+
+    def self.parse_remote_args argv, &block
+      options = {}
+
+      opts = opt_parser(options) do |opt|
+        opt.separator nil
+        opt.separator "Options:"
+
+        yield(opt, options) if block_given?
+
+        opt.on('-u', '--user USER',
+               'User to use for ssh login. Use with -r.') do |value|
+          options['user'] = value
+        end
+
+        opt.on('-r', '--remote server1,server2', Array,
+               'Run on one or more remote servers.') do |servers|
+          options['servers'] = servers
+        end
+
+        formats = %w{txt yml json}
+        opt.on('-f', '--format FORMAT', formats,
+               "Set the output format (#{formats.join(', ')})") do |format|
+          options['format'] = "#{format}_format".to_sym
+        end
+
+        opt.on('-v', '--verbose',
+               'Run in verbose mode.') do
+          options['verbose'] = true
+        end
+      end
+
+      opts.parse! argv
+
+
+      if options['servers']
+        options['servers'].map! do |host|
+          RemoteShell.new host, :user => options['user']
+        end
+      else
+        options['servers'] = [Sunshine.shell]
+      end
+
+      options['format'] ||= :txt_format
+
+
+      if options['sudo']
+        options['servers'].each do |ds|
+          ds.sudo = options['sudo']
+        end
+      end
+
+      options
+    end
+
+
+    ##
+    # Build a Sunshine command response
+
+    def self.build_response status, data
+      {'status' => status, 'data' => data}.to_yaml
+    end
+  end
+end