breeze 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+config/*
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+/Thorfile

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in breeze.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Markus Bengts
+
+MIT License
+
+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,4 @@
+# breeze
+
+Breeze provides some [Thor](https://github.com/wycats/thor) tasks and example scripts for managing cloud computing resources
+on [Amazon's AWS cloud](http://aws.amazon.com/).

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/breeze

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+
+module Breeze
+  class Runner < Thor
+
+    desc 'init [SERVER_TYPE]', 'Initialize a new project with templates for scripts and configuration files'
+    def init(*args)
+      require 'breeze/initializer'
+      invoke('breeze:initializer:init')
+    end
+
+  end
+end
+
+Breeze::Runner.start

data/breeze.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "breeze"
+
+Gem::Specification.new do |s|
+  s.name        = "breeze"
+  s.version     = Breeze::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Markus Bengts"]
+  s.email       = ["markus.bengts@gmail.com"]
+  s.homepage    = "https://github.com/markus/breeze"
+  s.summary     = %q{Thor tasks to manage AWS cloud computing resorces and deployments}
+  s.description = <<-END_DESCRIPTION
+Breeze makes it easy to automate server installation and configuration. It provides
+example scripts and configuration files that you can modify and keep in your revision
+control system. Thor tasks are provided to create server images, launch server instances etc.
+END_DESCRIPTION
+
+  s.rubyforge_project = "breeze"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('thor')
+  s.add_dependency('fog', '>= 0.7')
+end

data/lib/breeze.rb

@@ -0,0 +1,6 @@
+module Breeze
+
+  VERSION = "0.0.1"
+  autoload :Veur, 'breeze/veur'
+
+end

data/lib/breeze/fog_extensions.rb

@@ -0,0 +1,2 @@
+require 'fog'
+require 'breeze/fog_extensions/aws'

data/lib/breeze/fog_extensions/aws.rb

@@ -0,0 +1,65 @@
+require 'fog/compute/models/aws/server'
+require 'fog/compute/models/aws/image'
+
+module Fog
+
+  module AWS
+    class Compute::Server
+
+      def name
+        breeze_data['name'] || tags['Name']
+      end
+
+      def display_name
+        name || public_ip_address || "#{state} #{flavor_id} #{id}"
+      end
+
+      def running? ; current_state == 'running' ; end
+      def stopped? ; current_state == 'stopped' ; end
+
+      # Get or set meta data that is saved in a tag.
+      def breeze_data(new_values=nil)
+        if new_values
+          tags['breeze-data'] = new_values.map{ |k,v| v.nil? ? v : "#{k}:#{v}" }.compact.join(';')
+          # thor("server:tag:create #{id} breeze-data '#{tags['breeze-data']}'")
+          Breeze::Server::Tag.new.create(id, 'breeze-data', tags['breeze-data'])
+        else
+          Hash[tags['breeze-data'].to_s.split(';').map{ |s| s.split(':') }]
+        end
+      end
+
+      def spare_for_rollback!
+        breeze_state('spare_for_rollback')
+      end
+
+      def spare_for_rollback?
+        breeze_state == 'spare_for_rollback'
+      end
+
+      # Get or set the state tag.
+      def breeze_state(new_state=nil)
+        if new_state
+          breeze_data(breeze_data.merge('state' => new_state))
+        else
+          breeze_data['state']
+        end
+      end
+
+      private
+
+      def current_state
+        reload
+        state
+      end
+
+    end
+    class Compute::Image
+
+      def full_type
+        "#{type}, #{architecture}, #{root_device_type}"
+      end
+
+    end
+  end
+
+end

data/lib/breeze/initializer.rb

@@ -0,0 +1,40 @@
+require 'thor'
+
+module Breeze
+  class Initializer < Thor
+
+    include Thor::Actions
+
+    desc 'init [SERVER_PROFILE]', 'described in bin/breeze'
+    def init(profile='rails_and_image_magick')
+      raise(ArgumentError, "*#{profile}* is not supported") unless profile_exists?(profile)
+      copy_file('Thorfile')
+      copy_file('maintenance.html', "#{config_dir}/maintenance.html")
+      copy_file('user_data.sh', "#{config_dir}/user_data.sh")
+      directories('shared', profile_path(profile))
+      chmod_600('Thorfile', "#{config_dir}/scripts/credentials.sh")
+    end
+
+    private
+
+    def profile_exists?(profile)
+      File.directory?("#{self.class.source_root}/#{profile_path(profile)}")
+    end
+
+    def directories(*dirs)
+      dirs.each{ |dir| directory(dir, config_dir) }
+    end
+
+    def chmod_600(*files)
+      files.each{ |file| chmod(file, 0600) }
+    end
+
+    def config_dir      ; "config/breeze" ; end
+    def profile_path(p) ; "profiles/#{p}" ; end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..', 'templates')
+    end
+
+  end
+end

data/lib/breeze/tasks.rb

@@ -0,0 +1,10 @@
+require 'breeze'
+require 'breeze/tasks/configuration'
+require 'breeze/tasks/list'
+require 'breeze/tasks/server'
+require 'breeze/tasks/server/address'
+require 'breeze/tasks/server/image'
+require 'breeze/tasks/server/tag'
+require 'breeze/tasks/dns'
+require 'breeze/tasks/db'
+require 'breeze/tasks/app'

data/lib/breeze/tasks/app.rb

@@ -0,0 +1,145 @@
+require 'breeze/tasks/server'
+
+module Breeze
+
+  class App < Server
+
+    desc 'start PUBLIC_SERVER_NAME [DB_SERVER_NAME] [DB_NAME]', 'Start a new app with web server and db'
+    method_options :db => true, :db_to_clone => :string, :elastic_ip => true, :dns_ttl => 60, :deploy_branch => :string
+    def start(public_server_name, db_server_name=nil, db_name=nil)
+      if options[:db]
+        raise 'DB_SERVER_NAME is required unless --no-db is given.' if db_server_name.nil?
+        if options[:db_to_clone]
+          thor("db:clone #{options[:db_to_clone]} #{db_server_name}")
+        else
+          thor("db:create #{db_server_name} #{db_name}")
+        end
+      end
+      server = create_server
+      server.breeze_data(:name => public_server_name, :db => db_server_name)
+      thor("server:address:create #{server.id}") if options[:elastic_ip]
+      thor("dns:record:create #{zone_id(public_server_name)} #{public_server_name}. A #{ip(server)} #{options[:dns_ttl]}")
+      deploy_command([server], public_server_name, db_server_name, options[:deploy_branch]) if options[:deploy_branch]
+    end
+
+    desc 'stop PUBLIC_SERVER_NAME', 'Destroy web server and db'
+    method_options :force => false
+    def stop(public_server_name)
+      dbs_to_destroy = []
+      active_servers(public_server_name).each do |server|
+        server.addresses.each do |address|
+          thor("server:address:release #{address.public_ip}")
+        end
+        thor("dns:record:destroy #{zone_id(public_server_name)} #{public_server_name}. A")
+        dbs_to_destroy << server.breeze_data['db']
+        thor("server:destroy #{server.id}")
+      end
+      dbs_to_destroy.uniq.compact.each do |db_name|
+        thor("db:destroy #{db_name}")
+      end
+    end
+
+    desc 'disable PUBLIC_SERVER_NAME', 'Upload system/maintenance.html to web servers'
+    def disable(public_server_name)
+      on_each_server(disable_app_command, public_server_name)
+    end
+
+    desc 'enable PUBLIC_SERVER_NAME', 'Remove system/maintenance.html from web servers'
+    def enable(public_server_name)
+      on_each_server(enable_app_command, public_server_name)
+    end
+
+    desc 'deploy PUBLIC_SERVER_NAME DB_SERVER_NAME BRANCH', 'Deploy a new version by replacing old servers with new ones'
+    def deploy(public_server_name, db_server_name, branch)
+      old_server = active_servers(public_server_name).first
+      new_server = create_server
+      new_server.breeze_data(:name => public_server_name, :db => db_server_name)
+      deploy_command([new_server], public_server_name, db_server_name, branch)
+      puts("The new server should soon be available at #{ip(new_server)}.")
+      if ask("Ready to continue and move the elastic_ip for #{public_server_name} to the new server? [YES/rollback] >") =~ /r|n/i
+        remote("sudo shutdown -h +#{CONFIGURATION[:rollback_window]}", :host => ip(old_server))
+        old_server.spare_for_rollback!
+        move_addresses(old_server, new_server)
+      else
+        new_server.destroy
+      end
+    end
+
+    desc 'rollback PUBLIC_SERVER_NAME', 'Rollback a deploy'
+    def rollback(public_server_name)
+      old_server = spare_servers(public_server_name).first
+      remote('sudo shutdown -c', :host => ip(old_server))
+      new_server = active_servers(public_server_name).first
+      remote(disable_app_command, :host => ip(new_server))
+      move_addresses(new_server, old_server)
+      old_server.breeze_state('reactivated')
+      new_server.breeze_state('abandoned_due_to_rollback')
+      if accept?('Destroy the abandoned server NOW?')
+        new_server.destroy
+      end
+    end
+
+    private
+
+    def move_addresses(from_server, to_server)
+      from_server.addresses.each do |address|
+        thor("server:address:associate #{address.public_ip} #{to_server.id}")
+      end
+    end
+
+    def servers(public_server_name)
+      fog.servers.select{ |s| s.name == public_server_name }
+    end
+
+    def spare_servers(public_server_name)
+      servers(public_server_name).select{ |s| s.spare_for_rollback? }
+    end
+
+    def active_servers(public_server_name)
+      servers(public_server_name).select{ |s| ! s.spare_for_rollback? }
+    end
+
+    def on_each_server(command, public_server_name)
+      active_servers(public_server_name).each do |server|
+        remote(command, :host => ip(server))
+      end
+    end
+
+    def disable_app_command
+      "cd #{CONFIGURATION[:app_path]} && cp config/breeze/maintenance.html public/system/"
+    end
+
+    def enable_app_command
+      "rm #{CONFIGURATION[:app_path]}/public/system/maintenance.html"
+    end
+
+    def db_endpoint(db_server_name)
+      db = rds.servers.get(db_server_name)
+      return nil unless db
+      unless db.ready?
+        print('Waiting for the db')
+        wait_until { db.reload; db.ready? }
+      end
+      db.endpoint['Address']
+    end
+
+    def ip(server)
+      address = server.addresses.first
+      address ? address.public_ip : server.public_ip_address
+    end
+
+    def zone_id(name)
+      find_zone_recursively(name).id or raise("CANNOT FIND DNS ZONE FOR #{name}")
+    end
+
+    def find_zone_recursively(name)
+      return nil unless name.include?('.')
+      dns.zones.detect{ |z| z.domain == "#{name}." } or find_zone_recursively(name.sub(/[^.]*\./, ''))
+    end
+
+    def thor(task)
+      super(task + (options[:force] ? ' --force' : ''))
+    end
+
+  end
+end

data/lib/breeze/tasks/configuration.rb

@@ -0,0 +1,63 @@
+require 'erb'
+require 'fileutils'
+require 'socket'
+
+module Breeze
+
+  # The idea was stolen from rubber: https://github.com/wr0ngway/rubber
+  # but this is a simple implementation with no support for roles and additives.
+  # See https://github.com/wr0ngway/rubber/wiki/Configuration
+  class Configuration < Veur
+
+    desc 'deploy_to_localhost',
+      'Transform and deploy server configuration files to the local file system based on ERB templates in config/server'
+    method_option :force, :default => false, :desc => 'Overwrite and execute @post commands even if files would not change'
+    def deploy_to_localhost
+      Dir['config/breeze/configs/**/*'].each do |path|
+        transform_and_deploy(path, options[:force]) unless File.directory?(path)
+      end
+    end
+
+    private
+
+    def transform_and_deploy(file, force=false)
+      @read_cmd = @write_cmd = @path = @perms = @owner = @group = @post = nil
+      transformed = ERB.new(File.read(file)).result(binding)
+      original = IO.read(@path||"|#{@read_cmd}") if @path.nil? or File.exist?(@path)
+      report_errors(@read_cmd)
+      if force or original != transformed
+        ensure_directory_and_backup if @path
+        open(@path||"|#{@write_cmd}", 'w') { |f| f.write(transformed) }
+        report_errors(@write_cmd)
+        set_owner_and_permissions if @path
+        if @post
+          system("set -e; #{@post}")
+          report_errors(@post)
+        end
+      end
+    end
+
+    def ensure_directory_and_backup
+      if File.exist?(@path)
+        FileUtils.cp(@path, "#{@path}.backup", :preserve => true)
+      else
+        FileUtils.mkdir_p(File.dirname(@path))
+      end
+    end
+
+    def set_owner_and_permissions
+      FileUtils.chmod(@perms, @path) if @perms
+      FileUtils.chown(@owner, @group, @path) if @owner || @group
+    end
+
+    def report_errors(cmd)
+      raise "COMMAND FAILED: #{cmd}" unless $?.nil? || $?.success?
+    end
+
+    # a helper for ERB templates
+    def host_name
+      Socket.gethostname
+    end
+
+  end
+end

data/lib/breeze/tasks/db.rb

@@ -0,0 +1,31 @@
+module Breeze
+
+  class Db < Veur
+
+    desc 'create SERVER_NAME [DB_NAME]', 'Create a new database server'
+    method_options CONFIGURATION[:default_db_options]
+    def create(name, db_name=nil)
+      options.update(:id => name, :db_name => db_name)
+      # puts "DB options: #{options}"
+      rds.servers.create(options)
+    end
+
+    desc 'destroy NAME', 'Destroy a database server'
+    method_options :force => false
+    def destroy(name)
+      db = rds.servers.get(name)
+      if not %w(available failed storage-full incompatible-parameters incompatible-restore).include?(db.state)
+        puts "ERROR: cannot destroy db while state is #{db.state}!"
+      elsif force_or_accept?("Destroy DB #{name}?")
+        db.destroy(nil)
+        db.reload
+      end
+    end
+
+    desc 'clone OLD_DB NEW_DB', 'Create a new db server using the latest backup of OLD_DB.'
+    def clone(old_db, new_db)
+      rds.restore_db_instance_to_point_in_time(old_db, new_db, 'UseLatestRestorableTime' => true)
+    end
+
+  end
+end