sunshine 1.0.0.pre

data/History.txt

@@ -0,0 +1,237 @@
+=== 1.0.0 / 2010-03-26
+
+* Improvements:
+
+  * Removed all Atti-specific code for public release.
+
+* Bugfixes:
+
+  * Fixed Nginx passenger implementation.
+
+
+=== 0.0.6 / 2010-03-19
+
+* Major:
+
+  * Removed DeployServerDispatcher. Dispatching now happens at the App level.
+
+  * Moved Settler into Sunshine and renamed it to DependencyLib.
+
+* Improvements:
+
+  * Added INT signal handling to exit deploys and close connections gracefully.
+
+  * Added dependency installation methods apt_install, gem_install,
+    tpkg_install and yum_install to App and ServerApp.
+
+  * Extended functionality of ServerApp#upload_tasks.
+
+  * ServerApp now support being instatiated with an App instance (for 
+    coordinated deploys) or just with an app name (for post-deploy usage).
+
+  * Added a Sunshine rakefile template for task-based deploys.
+    Available through: sunshine --rakefile [COPY_TO]
+
+  * App#name gets auto-assigned by repo info if not provided.
+
+  * Sunshine::web_directory used to determine App#deploy_path when missing.
+
+  * Repo#detect now returns a Repo object instead of an array.
+
+  * Added start/stop/restart/status methods to DeployServerApp.
+
+  * ServerApp instances with unspecified roles get all roles by default.
+
+  * App config files now use erb parsing.
+    Any key/value passed the App constructor as a hash should be passed
+    to the erb binding along with the deploy_env.
+
+  * Added support to bundler for defining multiple dependencies with the same
+    name, and different package managers.
+
+* Bugfixes:
+
+  * Added setup checking to Daemon to only run setup when needed.
+
+  * Moved healthcheck from App to ServerApp and improved the api.
+
+  * Renamed DeployServerApp to ServerApp.
+
+  * Renamed App#deploy_path and App#deploys_dir to
+    App#root_path and App#deploys_path.
+
+  * Renamed the 'deploy' command to 'run' to more accurately express it's use.
+
+  * RsyncRepo#do_checkout fixed to match standard Repo#do_checkout methods.
+
+  * Sunshine::DATA and Sunshine::PATH are now set when running standalone
+    ruby deploy files.
+
+
+=== 0.0.5 / 2010-02-26
+
+* Sunshine::App:
+
+  * Use of DeployServerDispatcher threading
+
+  * Fixed control script creation to be deploy_server specific
+    (takes roles into account)
+
+  * Added AttiApp class for ATTi app deployment.
+
+  * Constuctor supports :deploy_name option for nameable deploys.
+    Defaults to the timestamp.
+
+  * Auto-detects if the script's directory is a checked out repo and uses it
+    if no repo information was given.
+
+  * Support for running sass.
+
+* Sunshine::DeployServerDispatcher:
+
+  * Added threading support
+
+* Sunshine::Repo:
+
+  * Added support for detecting a repo type based on a path:
+      Repo.detect [path [, console_or_deploy_server]]
+        #=> [:git, "git://url/of/git/repo", {:tree => "master", ...}]
+
+  * Moved info instance methods to the class
+
+  * Support for git-svn:
+      SvnRepo.git_svn? path
+
+  * Changed the checkout_to method signature
+
+* Sunshine::Server:
+
+  * Added support for ar_sendmail server.
+
+
+=== 0.0.4 / 2010-02-12
+
+* Added sudo functionality:
+
+  * Support for :sudo option on Sunshine::App, Sunshine::Server, and
+    Sunshine::DeployServer constructors, and attr_accessor :sudo
+
+  * Settler Dependency classes support a default sudo value:
+      Sunshine::Dependencies::Gem.sudo = true   # use sudo
+      Sunshine::Dependencies::Gem.sudo = "usr"  # use sudo -u usr
+      Sunshine::Dependencies::Gem.sudo = false  # ensure sudo is off
+      Sunshine::Dependencies::Gem.sudo = nil    # use :call obj precedence
+
+* App supports passing a (yml) file object to the constructor.
+  Useful for passing file DATA if desired:
+    app = Sunshine::App.new Sunshine::DATA
+    app.deploy!{|app| Sunshine::Rainbows.new(app).restart }
+    __END__
+    #yaml for app goes here...
+
+* App class changes:
+
+  * Changed the format of the App#checkout_path directory
+
+  * Logrotate setup now has to be called explicitely
+
+* Commands functionality expanded:
+
+  * Support for --sudo and --sudo=user on all Sunshine commands
+
+  * Added --format option for control commands. Supports txt, yml, json.
+
+* Control scripts generated on the remote server now keep deploy-time
+  shell_env variables:
+
+  * Run commands with the --no-env option to run without
+    deploy shell_env variables.
+
+  * Run any script with the app's env variables using:
+      /path/to/app/env some_command
+      /path/to/app/env EXTRA_VAR=some_value some_command
+    Supports all options the env command supports.
+
+* Dependency handling now supports apt.
+
+* DeployServers now support passing custom flags for ssh and rsync:
+    deploy_server = DeployServer.new "svr.com", :rsync_flags => [...]
+
+    deploy_server.call "some_command",
+      :sudo => "user", :flags => '-C'
+
+    deploy_server.upload "from", "to",
+      :sudo => "user", :flags => ['--chmod=ugo=rwX', '-b']
+
+    deploy_server.download "from", "to",
+      :flags => '--ignore-existing'
+
+* Repo implementation has significantly changed:
+
+  * Added support for git repo.
+
+  * Info about a repo is now retrieved with Repo#get_repo_info:
+      repo.get_repo_info deploy_server, checkout_path
+
+  * Repo constructor supports options hash with :flags option.
+
+
+=== 0.0.3 / 2010-01-29
+
+* Many small bugfixes
+
+* Tests, tests, and more tests
+
+* Changed DeployServer api
+
+  * DeployServer#run is not longer supported, use DeployServer#call
+
+  * Constructor supports a spaced delimited list for roles:
+      DeployServer.new "myhost.com", :roles => "web db other"
+
+  * Changed how deploy server yaml is parsed. Should parse to be valid on:
+      DeployServer.new *parsed_yaml
+    Example Given:
+      :deploy_servers :
+        - server1.com
+        - - server2.com
+        - - server3.com
+          - :roles : web db other
+            :ssh_flags : '-o ControlMaster=auto'
+
+
+=== 0.0.2 / 2010-01-15
+
+* Added Control Commands
+
+  * add, deploy, list, restart, rm, start, stop
+
+* Application support
+
+  * Changed VERSION file to info and its format to yaml
+
+  * Deployed apps now have a start, stop and restart script
+
+  * Added Crontab and log rotation support
+
+* Functional changes
+
+  * Ditched net/ssh and net/scp for ssh and rsync through Open4
+
+  * Fixed and updated dependencies to use Yum
+
+  * Support for sunshine user configuration in ~/.sunshine
+
+* Rake tasks
+
+  * Support to run the app's rake tasks
+
+  * Built in default ATTi rake tasks
+
+
+=== 0.0.1 / 2009-11-18
+ 
+* 1 major enhancement
+ 
+  * First release!
+

data/Manifest.txt

@@ -0,0 +1,70 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/sunshine
+examples/deploy.rb
+examples/deploy_tasks.rake
+examples/standalone_deploy.rb
+lib/commands/add.rb
+lib/commands/default.rb
+lib/commands/list.rb
+lib/commands/restart.rb
+lib/commands/rm.rb
+lib/commands/run.rb
+lib/commands/start.rb
+lib/commands/stop.rb
+lib/sunshine.rb
+lib/sunshine/app.rb
+lib/sunshine/binder.rb
+lib/sunshine/crontab.rb
+lib/sunshine/daemon.rb
+lib/sunshine/daemons/ar_sendmail.rb
+lib/sunshine/daemons/delayed_job.rb
+lib/sunshine/daemons/nginx.rb
+lib/sunshine/daemons/rainbows.rb
+lib/sunshine/daemons/server.rb
+lib/sunshine/daemons/unicorn.rb
+lib/sunshine/dependencies.rb
+lib/sunshine/dependency_lib.rb
+lib/sunshine/exceptions.rb
+lib/sunshine/healthcheck.rb
+lib/sunshine/output.rb
+lib/sunshine/package_managers/apt.rb
+lib/sunshine/package_managers/dependency.rb
+lib/sunshine/package_managers/gem.rb
+lib/sunshine/package_managers/yum.rb
+lib/sunshine/remote_shell.rb
+lib/sunshine/repo.rb
+lib/sunshine/repos/git_repo.rb
+lib/sunshine/repos/rsync_repo.rb
+lib/sunshine/repos/svn_repo.rb
+lib/sunshine/server_app.rb
+lib/sunshine/shell.rb
+templates/logrotate/logrotate.conf.erb
+templates/nginx/nginx.conf.erb
+templates/nginx/nginx_optimize.conf
+templates/nginx/nginx_proxy.conf
+templates/rainbows/rainbows.conf.erb
+templates/tasks/sunshine.rake
+templates/unicorn/unicorn.conf.erb
+test/fixtures/app_configs/test_app.yml
+test/fixtures/sunshine_test/test_upload
+test/mocks/mock_object.rb
+test/mocks/mock_open4.rb
+test/test_helper.rb
+test/unit/test_app.rb
+test/unit/test_binder.rb
+test/unit/test_crontab.rb
+test/unit/test_git_repo.rb
+test/unit/test_healthcheck.rb
+test/unit/test_nginx.rb
+test/unit/test_rainbows.rb
+test/unit/test_remote_shell.rb
+test/unit/test_repo.rb
+test/unit/test_server.rb
+test/unit/test_server_app.rb
+test/unit/test_shell.rb
+test/unit/test_sunshine.rb
+test/unit/test_svn_repo.rb
+test/unit/test_unicorn.rb

data/README.txt

@@ -0,0 +1,277 @@
+= Sunshine
+
+http://betalabs.yellowpages.com/
+
+== Description
+
+Sunshine is an object-oriented api for rack application deployment.
+
+Sunshine is open and it can do a lot! It's meant to be dug into and understood.
+Knowing how it works will let you do really neat things: classes are
+decoupled as much as possible to allow for optimal flexibility,
+and most can be used independently.
+
+This gem was made possible by the sponsoring of AT&T Interactive
+(http://attinteractive.com).
+
+== Setup
+
+Installing sunshine:
+
+  gem install sunshine
+
+You can either use sunshine by requiring the gem in your script or
+by calling the sunshine command:
+
+  sunshine run my_deploy.rb -e qa
+
+
+== Deploy Scripts
+
+Writing a Sunshine script is easy:
+
+  options = {
+    :name => 'myapp',
+    :repo => {:type => :svn, :url => 'svn://blah...'},
+    :root_path => '/usr/local/myapp'
+  }
+
+  options[:remote_shells] = case Sunshine.deploy_env
+  when 'qa'
+    ['qa1.svr.com', 'qa2.svr.com']
+  else
+    'localhost'
+  end
+
+  Sunshine::App.deploy(options) do |app|
+
+    app_server = Sunshine::Rainbows.new(app)
+    app_server.restart
+
+    Sunshine::Nginx.new(app, :point_to => app_server).restart
+
+  end
+
+
+The App::deploy and App::new methods also support passing
+a path to a yaml file:
+
+  app = Sunshine::App.new("path/to/config.yml")
+  app.deploy{|app| Sunshine::Rainbows.new(app).restart }
+
+
+The yaml file can also be any IO stream whos output will parse to yaml.
+This can be ueful for passing the file's DATA and keep all the deploy
+information in one place:
+
+    # The following two lines are equivalent:
+    app = Sunshine::App.new
+    app = Sunshine::App.new Sunshine::DATA
+
+    app.deploy{|app| Sunshine::Rainbows.new(app).restart }
+
+    __END__
+
+    # yaml for app goes here...
+
+
+Yaml files are read on a deploy-environment basis so its format reflects this:
+
+  ---
+  # Default is always inherited by all environments
+  :default :
+    :name : app_name
+    :repo :
+      :type : svn
+      :url :  svn://subversion/app_name/branches/continuous_integration
+
+    :root_path : /usr/local/app_name
+
+    :remote_shells :
+      - - localhost
+        - :roles : web db app
+
+  # Setup for qa environment
+  :qa :
+    :repo :
+      :type : svn
+      :url :  svn://subversion/app_name/tags/release_0001
+    :remote_shells :
+      - qa1.servers.com
+      - qa2.servers.com
+
+  # Prod inherits top level values from :qa
+  :prod :
+    :inherits : :qa
+    :remote_shells :
+      - prod1.servers.com
+      - prod2.servers.com
+
+In this example, :prod inherits top level values from :qa (only :repo in this
+instance). The :inherits key also supports an array as its value.
+
+
+== Using rake is great!
+
+Although Sunshine comes with it's own bundle of commands, they should be used
+to control deployed apps on remote servers in instances where deploy information
+(e.g. your deploy yaml file) is unavailable. Their purpose is to query a server
+where Sunshine apps have been deployed and have a nominal amount of information
+and control over them. Sunshine control commands are run on a per-server basis.
+
+Most of the time though, you'll want to control the deploy on a per-app basis.
+You have the deploy information and you need to do things involving that
+specific deploy. Rake tasks are great for that, and Sunshine comes with a
+template rake file that you can modify to fit your needs.
+
+You can copy the template rake file to lib/tasks/ by running:
+  sunshine --rakefile lib/tasks/.
+
+If you open the file, you'll see a variety of tasks that handle deployment, to
+application start/stop/restart-ing, to health checks. Most likely, the two tasks
+you'll need to update are the :app (for instantiation) and the :deploy tasks.
+
+First off, if you're using rails, you'll probably want to update "task :app" to
+"task :app => :environment" in order to get all the rails environment goodness.
+You'll also want to make sure that the @app object gets instantiated with the
+proper hash value or yaml file.
+
+Second, you need to update your :deploy task. Add whatever instructions you need
+to the @app.deploy block.
+
+And that's it! Try running your Sunshine rake tasks!
+
+  rake sunshine:app             # Instantiate Sunshine
+  rake sunshine:db_migrate      # Run db:migrate on remote :db servers
+  rake sunshine:deploy          # Deploy the app
+  rake sunshine:health          # Get the health state
+  rake sunshine:health:disable  # Turn off health check
+  rake sunshine:health:enable   # Turn on health check
+  rake sunshine:health:remove   # Remove health check
+  rake sunshine:info            # Get deployed app info
+  rake sunshine:restart         # Run the remote restart script
+  rake sunshine:start           # Run the remote start script
+  rake sunshine:status          # Check if the deployed app is running
+  rake sunshine:stop            # Run the remote stop script
+  
+
+
+== Dependencies
+
+Sunshine has simple, basic dependency support, and relies mostly on preexisting
+package manager tools such as apt, yum, or rubygems. Dependencies or packages
+can be defined independently, or as a part of a dependency tree
+(see Sunshine::DependencyLib). Sunshine has its own internal dependency tree
+which can be modified but users can also create their own.
+
+
+=== User Dependencies
+
+The most common way of using dependencies is through ServerApp:
+
+  server_app.apt_install 'postgresql', 'libxslt'
+  server_app.gem_install 'json', :version => '>=1.0.0'
+
+This should be plenty for most users. You can however create simple standalone
+package definitions:
+
+  postgresql = Sunshine::Apt.new('postgresql')
+  postgresql.install! :call => server_app.shell
+
+You can imagine how this would be useful to do server configuration
+with Sunshine:
+
+  server = RemoteShell.new "user@myserver.com"
+  server.connect
+
+  %w{postgresql libxslt ruby-full rubygems}.each do |dep_name|
+    Sunshine::Apt.new(dep_name).install! :call => server
+  end
+
+Warning: If the :call options isn't specified, the dependency will attempt to
+install on the local system.
+
+
+=== Internal Sunshine Dependencies (advanced)
+
+Sunshine's default dependencies are defined in Sunshine.dependencies and can
+be overridden as needed:
+
+  Sunshine.dependencies.get 'rubygems', :type => Sunshine::Yum
+  #=> <Sunshine::Yum ... version='1.3.5' >
+  # Not what you want? Replace it:
+
+  Sunshine.dependencies.yum 'rubygems', :version => '1.3.2'
+
+Any dependencies added or modified in Sunshine.dependencies are used as a part
+of the internal Sunshine workings. Also to note: ServerApp#pkg_manager is
+crucial in defining which dependency to use. By default, a server_app's
+package manager will be either Yum or Apt depending on availability. That can
+be overridden with something like:
+
+  server_app.pkg_manager = Sunshine::Yum
+
+An array can also be given and the server_app will attempt to install available
+dependencies according to that type order:
+
+  server_app.pkg_manager = [Sunshine::Tpkg, Sunshine::Yum]
+
+In this instance, if no Tpkg dependency was defined in Sunshine.dependencies,
+the server_app will look for a Yum dependency. If you want to ensure all your
+server_apps use the same dependency definition, you may consider:
+
+  Sunshine.dependencies.yum 'rubygems', :version => '1.3.2'
+  Sunshine.dependencies.apt 'rubygems', :version => '1.3.2'
+  # ... and so on
+
+
+== Deployed Application Control
+
+Sunshine has a variety of commands that allow simple control of
+remote or locally deployed applications. These include start, stop, restart
+actions to be taken application-wide, as well as querying for the
+health and state of the app:
+
+Examples:
+  sunshine run deploy_script.rb
+  sunshine restart myapp -r user@server.com,user@host.com
+  sunshine list myapp myotherapp --health -r user@server.com
+  sunshine list myapp --status
+
+The Sunshine commands are as follows:
+  add       Register an app with sunshine
+  list      Display deployed apps
+  restart   Restart a deployed app
+  rm        Unregister an app with sunshine
+  run       Run a Sunshine script
+  start     Start a deployed app
+  stop      Stop a deployed app
+
+For more help on sunshine commands, use 'sunshine COMMAND --help'.
+For more information about control scripts, see the
+Sunshine::App#build_control_scripts method.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+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/Rakefile

@@ -0,0 +1,46 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'hoe'
+require 'rake'
+require 'rake/testtask'
+
+task :manifest do
+  manifest_file = "Manifest.txt"
+
+  gem_files = record_files do |f|
+    next if f =~ /^(tmp|pkg|deploy_tests)/
+    puts(f)
+    true
+  end
+
+  gem_files.push(manifest_file)
+  gem_files = gem_files.uniq.sort.join("\n")
+
+  File.open(manifest_file, "w+") do |file|
+    file.write gem_files
+  end
+end
+
+def record_files(path="*", file_arr=[], &block)
+  Dir[path].each do |child_path|
+    if File.file?(child_path)
+      next if block_given? && !yield(child_path)
+      file_arr << child_path
+    end
+    record_files(child_path+"/*", file_arr, &block) if
+      File.directory?(child_path)
+  end
+  return file_arr
+end
+
+Hoe.plugin :isolate
+
+Hoe.spec 'sunshine' do |p|
+  developer('Jeremie Castagna', 'jcastagna@attinteractive.com')
+  self.extra_deps << ['open4',    '>= 1.0.1']
+  self.extra_deps << ['rainbow',  '>= 1.0.4']
+  self.extra_deps << ['highline', '>= 1.5.1']
+end
+
+# vim: syntax=Ruby
+

data/bin/sunshine

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -w
+
+require 'sunshine'
+
+Sunshine.run

data/examples/deploy.rb

@@ -0,0 +1,61 @@
+Sunshine::App.deploy do |app|
+
+  app.shell_env "NLS_LANG"        => "American_America.UTF8",
+                "TNS_ADMIN"       => "#{app.current_path}/config",
+                "ORACLE_HOME"     => "/usr/lib/oracle/11.2/client64",
+                "LD_LIBRARY_PATH" => "/usr/lib/oracle/11.2/client64/lib"
+
+  app.gem_install 'isolate', :version => '1.3.0'
+
+  app.install_deps 'libxml2-devel', 'libxslt-devel', 'libaio', 'sqlite-devel',
+                  'sqlite', 'ruby-devel', 'activerecord-oracle_enhanced-adapter'
+
+
+  app.run_bundler
+
+
+  app.with_filter :role => :db do
+
+    app.rake 'config/database.yml'
+    app.rake 'db:migrate'
+  end
+
+
+  app.with_filter :role => :cdn do
+
+    sass_yml_file = "#{app.checkout_path}/config/asset_packages.yml"
+    sass_yml      = app.server_apps.first.shell.call "cat #{sass_yml_file}"
+    sass_files    = YAML.load(sass_yml)['stylesheets']
+
+    app.sass sass_files
+    app.rake 'asset:packager:build_all'
+  end
+
+
+  delayed_job = Sunshine::DelayedJob.new app
+  delayed_job.restart
+
+  mail = Sunshine::ARSendmail.new app
+  mail.restart
+
+  unicorn = Sunshine::Unicorn.new app, :port => 10001, :processes => 8
+  unicorn.restart
+
+  nginx = Sunshine::Nginx.new app, :point_to => unicorn, :port => 10000
+  nginx.restart
+end
+
+
+__END__
+
+:default:
+  :repo:
+    :type:  git
+    :url:   git://my_git_server.com/app_name.git
+    :flags: "--depth 5"
+
+  :root_path: ~my_user/app_name
+
+  :remote_shells:
+    - myserver1.com
+    - myserver2.com