breeze 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0700bdcae3cd19bf8920aeff10db9d3d4d5eaac6
+  data.tar.gz: 4aea1e6bf9898e114c2ebb87cd74ba3e5e1e5a5f
+SHA512:
+  metadata.gz: af99135461958862e35d01aa4966fe135ffbcbbc0ea7ff580aedab8016a65d1f3f9e153ca65879ccbac004fca704ca0a168a54440022b0eade90323cc38ef074
+  data.tar.gz: ff9683ce457c7af33c036bbb4d29aadf64bc48ac7a2007dcf89e28369f6112995b2e308a42eadba25601fbc7589836198684af718f4a04539204e784c3867cbe

data/.ruby-version

@@ -0,0 +1 @@
+2.1.1

data/Gemfile

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

data/README.md

@@ -5,7 +5,8 @@ and deployments. Currently only [Amazon's AWS cloud](http://aws.amazon.com/) is
 [fog](https://github.com/geemus/fog) for the hard work so it should be fairly easy to add support for other cloud computing
 providers that are supported by fog.
 
-Breeze implements zero downtime deploys and rollbacks by moving an elastic ip from one server to another. Db migrations have to be
+Breeze implements zero downtime deploys and rollbacks by moving an elastic ip from one server to another or by replacing
+server instances behind an [elastic load balancer](http://aws.amazon.com/elasticloadbalancing). Db migrations have to be
 compatible with the previous version. http://pedro.herokuapp.com/past/2011/7/13/rails_migrations_with_no_downtime/
 
 ## install
@@ -50,16 +51,16 @@ These tasks call app tasks with fixed parameters.
 
     app
     ---
-    thor app:deploy PUBLIC_SERVER_NAME DB_SERVER_NAME BRANCH      # Deploy a new version by replacing old servers with new ones
-    thor app:disable PUBLIC_SERVER_NAME                           # Upload system/maintenance.html to web servers
-    thor app:enable PUBLIC_SERVER_NAME                            # Remove system/maintenance.html from web servers
-    thor app:rollback PUBLIC_SERVER_NAME                          # Rollback a deploy
-    thor app:start PUBLIC_SERVER_NAME [DB_SERVER_NAME] [DB_NAME]  # Start a new app with web server and db
-    thor app:stop PUBLIC_SERVER_NAME                              # Destroy web server and db
+    thor app:deploy PUBLIC_SERVER_NAME    # Deploy a new version by replacing old servers with new ones
+    thor app:disable PUBLIC_SERVER_NAME   # Upload system/maintenance.html to web servers
+    thor app:enable PUBLIC_SERVER_NAME    # Remove system/maintenance.html from web servers
+    thor app:rollback PUBLIC_SERVER_NAME  # Rollback a deploy
+    thor app:start PUBLIC_SERVER_NAME     # Start a new app with web server and db
+    thor app:stop PUBLIC_SERVER_NAME      # Destroy web server and db
     
     configuration
     -------------
-    thor configuration:deploy_to_localhost  # Transform and deploy server configuration files to the local file system based...
+    thor configuration:deploy_to_localhost [FILE]  # Transform and deploy server configuration files to the local file system based on ERB templates in config/server
     
     db
     --
@@ -67,32 +68,47 @@ These tasks call app tasks with fixed parameters.
     thor db:create SERVER_NAME [DB_NAME]  # Create a new database server
     thor db:destroy NAME                  # Destroy a database server
     
-    dns
-    ---
-    thor dns:record:create ZONE_ID NAME TYPE IP [TTL]  # Create a new DNS record
-    thor dns:record:destroy ZONE_ID NAME [TYPE]        # Destroy a DNS record
-    thor dns:zone:create DOMAIN                        # Create a new DNS zone
-    thor dns:zone:destroy ZONE_ID                      # Destroy a DNS zone
-    thor dns:zone:import ZONE_ID FILE                  # Creates dns records specified in FILE
-    
     describe
     --------
     thor describe:addresses            # List allocated ip addresses
+    thor describe:cache_clusters       # Describe ElastiCache clusters
     thor describe:cloud_resources      # List all cloud resources that the current account can control with breeze
     thor describe:db_servers           # List database servers
     thor describe:dns_records ZONE_ID  # List all DNS records for the given zone
     thor describe:dns_zones            # Describe DNS zones
     thor describe:images               # Describe machine images owned by Breeze::CONFIGURATION[:image_owner]
+    thor describe:load_balancers       # Describe ELB load balancers
     thor describe:servers              # Describe server instances
     thor describe:volumes              # Describe block store volumes (EBS)
     
+    dns
+    ---
+    thor dns:record:create ZONE_ID NAME TYPE IP [TTL]  # Create a new DNS record
+    thor dns:record:destroy ZONE_ID NAME [TYPE]        # Destroy a DNS record
+    thor dns:zone:create DOMAIN                        # Create a new DNS zone
+    thor dns:zone:destroy ZONE_ID                      # Destroy a DNS zone
+    thor dns:zone:import ZONE_ID FILE                  # Creates dns records specified in FILE
+    
+    elasticache
+    -----------
+    thor elasticache:create CLUSTER_NAME   # Create a new cache cluster
+    thor elasticache:destroy CLUSTER_NAME  # Destroy a cache cluster
+    
+    elb
+    ---
+    thor elb:add_instances LOAD_BALANCER_NAME instance_id [instance_id, ...]     # Add server instances to a load balancer
+    thor elb:create LOAD_BALANCER_NAME [CNAME] [DNS_ZONE_ID]                     # Create a new elastic load balancer
+    thor elb:destroy LOAD_BALANCER_NAME                                          # Destroy an elastic load balancer
+    thor elb:remove_instances LOAD_BALANCER_NAME instance_id [instance_id, ...]  # Remove server instances from a load balancer
+    
     server
     ------
     thor server:address:associate IP NEW_SERVER_ID  # Associate an existing IP with a new server
     thor server:address:create SERVER_ID            # Create and associate a new elastic ip
     thor server:address:release IP                  # Release the ip address
     thor server:create                              # Launch a new server instance
-    thor server:destroy INSTANCE_ID                 # Terminate a running (or stopped) server instance
-    thor server:image:create                        # Launch a server with the base image, wait for it to boot, invoke...
+    thor server:destroy INSTANCE_ID [...]           # Terminate a running (or stopped) server instance
+    thor server:image:create                        # Launch a server with the base image, wait for it to boot, invoke prepare_private_image(ip_address), stop the server, create a new machine image as a snapshot of the root device, and destroy the server.
+    thor server:image:destroy IMAGE_ID [...]        # Deregister the image and destroy the related volume snapshot
     thor server:tag:create SERVER_ID KEY VALUE      # Create or update a tag
     thor server:tag:destroy SERVER_ID KEY           # Delete a tag

data/features/support/env.rb

@@ -35,4 +35,5 @@ system("echo 'Fog.mock!' >> #{thorfile_path}")
 Before do
   system("cp -r #{template_dir} tmp/aruba")
   @aruba_timeout_seconds = 5
+  @dirs = ['tmp/aruba/test_app_template']
 end

data/lib/breeze.rb

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

data/lib/breeze/fog_wrapper.rb

@@ -7,7 +7,7 @@ module Breeze
   module FogWrapper
 
     def self.connection(type)
-      {:compute => Compute, :dns => DNS, :rds => RDS}[type].get_connection
+      {compute: Compute, dns: DNS, rds: RDS, elasticache: Elasticache, elb: ELB}[type].get_connection
     end
 
     def self.flush_mock_data!
@@ -79,5 +79,23 @@ module Breeze
       def mock_class ; Fog::AWS::RDS::Mock ; end
     end
 
+    class Elasticache < AbstractConnectionWrapper
+      def self.direct_fog_connection
+        Fog::AWS::Elasticache.new(CONFIGURATION[:cloud_service])
+      end
+      private
+      def data_file  ; 'fog_elasticache_data.yaml' ; end
+      def mock_class ; Fog::AWS::Elasticache::Mock ; end
+    end
+
+    class ELB < AbstractConnectionWrapper
+      def self.direct_fog_connection
+        Fog::AWS::ELB.new(CONFIGURATION[:cloud_service])
+      end
+      private
+      def data_file  ; 'fog_elb_data.yaml' ; end
+      def mock_class ; Fog::AWS::ELB::Mock ; end
+    end
+
   end
 end

data/lib/breeze/tasks.rb

@@ -7,4 +7,6 @@ require 'breeze/tasks/server/image'
 require 'breeze/tasks/server/tag'
 require 'breeze/tasks/dns'
 require 'breeze/tasks/db'
+require 'breeze/tasks/elasticache'
+require 'breeze/tasks/elb'
 require 'breeze/tasks/app'

data/lib/breeze/tasks/app.rb

@@ -4,42 +4,63 @@ 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)
+    desc 'start PUBLIC_SERVER_NAME', 'Start a new app with web server and db'
+    method_options db: true, db_server_name: :string, db_name: :string, db_to_clone: :string,
+      elasticache: true, cache_cluster_name: :string,
+      elastic_ip: true, dns_ttl: 60,
+      elb_name: :string, elb_cname: true,
+      deploy_branch: :string
+    def start(public_server_name)
       if options[:db]
-        raise 'DB_SERVER_NAME is required unless --no-db is given.' if db_server_name.nil?
+        raise '--db-server-name is required unless --no-db is given.' if options[:db_server_name].nil?
         if options[:db_to_clone]
-          thor("db:clone #{options[:db_to_clone]} #{db_server_name}")
+          thor("db:clone #{options[:db_to_clone]} #{options[:db_server_name]}")
         else
-          thor("db:create #{db_server_name} #{db_name}")
+          thor("db:create #{options[:db_server_name]} #{options[:db_name]}")
         end
       end
-      server = create_server
-      server.breeze_data(:name => public_server_name, :db => db_server_name)
-      if options[:elastic_ip]
-        thor("server:address:create #{server.id}")
-        server.reload until server.addresses.first
+      if options[:elasticache]
+        raise '--cache-cluster-name is required unless --no-elasticache is given.' if options[:cache_cluster_name].nil?
+        thor("elasticache:create #{options[:cache_cluster_name]}")
+      end
+      if options[:elb_name]
+        create_elb_and_app_servers(public_server_name, options)
+      else
+        create_app_server_with_elastic_ip(public_server_name, options)
       end
-      deploy_command([server], public_server_name, db_server_name, options[:deploy_branch]) if options[:deploy_branch]
-      thor("dns:record:create #{zone_id(public_server_name)} #{public_server_name}. A #{ip(server)} #{options[:dns_ttl]}")
     end
 
     desc 'stop PUBLIC_SERVER_NAME', 'Destroy web server and db'
     method_options :force => false
     def stop(public_server_name)
       dbs_to_destroy = []
+      cache_clusters_to_destroy = []
+      elb_to_destroy = nil
       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']
+        cache_clusters_to_destroy << server.breeze_data['cache']
+        elb_to_destroy ||= server.breeze_data['elb']
         thor("server:destroy #{server.id}")
       end
       dbs_to_destroy.uniq.compact.each do |db_name|
         thor("db:destroy #{db_name}")
       end
+      cache_clusters_to_destroy.uniq.compact.each do |cache_cluster_name|
+        thor("elasticache:destroy #{cache_cluster_name}")
+      end
+      if elb_to_destroy
+        elb_cname_record = find_zone_recursively(public_server_name).records.detect{ |r| r.name == "#{public_server_name}." and r.type == 'CNAME' }
+        if elb_cname_record
+          thor("elb:destroy #{elb_to_destroy} #{public_server_name} #{zone_id(public_server_name)}")
+        else
+          thor("elb:destroy #{elb_to_destroy}")
+        end
+      else
+        thor("dns:record:destroy #{zone_id(public_server_name)} #{public_server_name}. A")
+      end
     end
 
     desc 'disable PUBLIC_SERVER_NAME', 'Upload system/maintenance.html to web servers'
@@ -52,12 +73,63 @@ module Breeze
       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)
+    desc 'deploy PUBLIC_SERVER_NAME', 'Deploy a new version by replacing old servers with new ones'
+    method_options db_server_name: :string, cache_cluster_name: :string, elb_name: :string, deploy_branch: :string
+    def deploy(public_server_name)
+      if options[:elb_name]
+        deploy_with_elb(public_server_name, options)
+      else
+        deploy_with_elastic_ip(public_server_name, options)
+      end
+    end
+
+    desc 'rollback PUBLIC_SERVER_NAME', 'Rollback a deploy'
+    method_options elb_name: :string
+    def rollback(public_server_name)
+      old_servers = spare_servers(public_server_name)
+      raise "no running spare server found for #{public_server_name}" if old_servers.size == 0
+      old_servers.each do |old_server|
+        unless ip(old_server) # the ip may be temporarily unknown if the old elastic ip has been moved to another instance
+          wait_until { old_server.reload; ip(old_server) }
+        end
+        remote('sudo shutdown -c', :host => ip(old_server))
+      end
+      new_servers = active_servers(public_server_name)
+      new_servers.each do |new_server|
+        remote(disable_app_command, :host => ip(new_server))
+      end
+      if options[:elb_name]
+        thor("elb:add_instances #{options[:elb_name]} #{old_servers.map(&:id).join(' ')}")
+        thor("elb:remove_instances #{options[:elb_name]} #{new_servers.map(&:id).join(' ')}")
+      else
+        move_addresses(new_servers.first, old_servers.first)
+      end
+      old_servers.each { |s| s.breeze_state('reactivated') }
+      new_servers.each { |s| s.breeze_state('abandoned_due_to_rollback') }
+      if accept?("Ready to destroy the abandoned #{new_servers.size} server(s) now?")
+        new_servers.each { |s| s.destroy }
+      end
+    end
+
+    private
+
+    def deploy_with_elb(public_server_name, options)
+      old_servers = active_servers(public_server_name)
+      create_app_servers_for_elb(public_server_name, options)
+      if accept?("Continue and remove the old servers from the ELB?")
+        thor("elb:remove_instances #{options[:elb_name]} #{old_servers.map(&:id).join(' ')}")
+        old_servers.each do |old_server|
+          remote("nohup sudo shutdown -h +#{CONFIGURATION[:rollback_window]} > /dev/null 2>&1 &", :host => ip(old_server))
+          old_server.spare_for_rollback!
+        end
+      end
+    end
+
+    def deploy_with_elastic_ip(public_server_name, options)
       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)
+      new_server.breeze_data(name: public_server_name, db: options[:db_server_name], cache: options[:cache_cluster_name])
+      deploy_command([new_server], public_server_name, options)
       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
         new_server.destroy
@@ -72,31 +144,48 @@ module Breeze
       end
     end
 
-    desc 'rollback PUBLIC_SERVER_NAME', 'Rollback a deploy'
-    def rollback(public_server_name)
-      old_server = spare_servers(public_server_name).first
-      raise "no running spare server found for #{public_server_name}" unless old_server
-      if ip(old_server)
-        temp_ip = nil
+    def create_elb_and_app_servers(public_server_name, options)
+      if options[:elb_cname]
+        thor("elb:create #{options[:elb_name]} #{public_server_name} #{zone_id(public_server_name)}")
       else
-        puts("Old server does not have a public ip. Allocating a temporary address:")
-        thor("server:address:create #{old_server.id}")
-        old_server.reload until old_server.addresses.first
-        temp_ip = ip(old_server)
-      end
-      remote('sudo shutdown -c', :host => ip(old_server))
-      new_server = active_servers(public_server_name).first
-      remote(disable_app_command, :host => ip(new_server))
-      thor("server:address:release #{temp_ip} --force") if temp_ip
-      move_addresses(new_server, old_server)
-      old_server.breeze_state('reactivated')
-      new_server.breeze_state('abandoned_due_to_rollback')
-      if accept?('Ready to destroy the abandoned server now?')
-        new_server.destroy
+        thor("elb:create #{options[:elb_name]}")
       end
+      create_app_servers_for_elb(public_server_name, options.merge(force: true))
     end
 
-    private
+    def create_app_servers_for_elb(public_server_name, options)
+      servers = []
+      CONFIGURATION[:elb][:instances].each do |instance_conf|
+        instance_conf = instance_conf.dup
+        instance_conf.delete(:count).times do
+          servers << create_server(CONFIGURATION[:default_server_options].merge(instance_conf))
+          set_server_tags(servers.last, public_server_name, options)
+        end
+      end
+      deploy_command(servers, public_server_name, options)
+      servers.each do |server|
+        if force_or_accept?("Ready to add #{ip(server)} to ELB #{options[:elb_name]}?")
+          thor("elb:add_instances #{options[:elb_name]} #{server.id}")
+        else
+          server.destroy
+        end
+      end
+    end
+
+    def create_app_server_with_elastic_ip(public_server_name, options)
+      server = create_server
+      set_server_tags(server, public_server_name, options)
+      if options[:elastic_ip]
+        thor("server:address:create #{server.id}")
+        server.reload until server.addresses.first
+      end
+      deploy_command([server], public_server_name, options)
+      thor("dns:record:create #{zone_id(public_server_name)} #{public_server_name}. A #{ip(server)} #{options[:dns_ttl]}")
+    end
+
+    def set_server_tags(server, public_server_name, options)
+      server.breeze_data(name: public_server_name, db: options[:db_server_name], cache: options[:cache_cluster_name], elb: options[:elb_name])
+    end
 
     def move_addresses(from_server, to_server)
       from_server.addresses.each do |address|
@@ -170,11 +259,19 @@ module Breeze
       c.class_eval <<-END_TASKS
       desc 'deploy', 'Deploy a new version by replacing old servers with new ones'
       def deploy
-        thor("app:deploy \#{PUBLIC_SERVER_NAME} \#{DB_SERVER_NAME} \#{BRANCH}")
+        if defined?(ELB_NAME)
+          thor("app:deploy \#{PUBLIC_SERVER_NAME} --db-server-name=\#{DB_SERVER_NAME} --cache-cluster-name=\#{CACHE_CLUSTER_NAME} --elb-name=\#{ELB_NAME} --deploy-branch=\#{BRANCH}")
+        else
+          thor("app:deploy \#{PUBLIC_SERVER_NAME} --db-server-name=\#{DB_SERVER_NAME} --cache-cluster-name=\#{CACHE_CLUSTER_NAME} --deploy-branch=\#{BRANCH}")
+        end
       end
       desc 'rollback', 'Rollback the previous deploy'
       def rollback
-        thor("app:rollback \#{PUBLIC_SERVER_NAME}")
+        if defined?(ELB_NAME)
+          thor("app:rollback \#{PUBLIC_SERVER_NAME} --elb-name=\#{ELB_NAME}")
+        else
+          thor("app:rollback \#{PUBLIC_SERVER_NAME}")
+        end
       end
       desc 'disable', 'Copy maintenance.html to public/system/ on active web servers'
       def disable
@@ -184,9 +281,10 @@ module Breeze
       def enable
         thor("app:enable \#{PUBLIC_SERVER_NAME}")
       end
-      desc 'ssh', 'Log in with ssh'
-      def ssh
-        log_in_to(PUBLIC_SERVER_NAME)
+      desc 'ssh [INSTANCE_ID]', 'Log in with ssh'
+      def ssh(instance_id=nil)
+        server = (instance_id ? fog.servers.get(instance_id) : active_servers(PUBLIC_SERVER_NAME)[0])
+        log_in_to(server.public_ip_address)
       end
       END_TASKS
     end

data/lib/breeze/tasks/describe.rb

@@ -12,6 +12,8 @@ module Breeze
       volumes
       db_servers
       dns_zones
+      cache_clusters
+      load_balancers
     end
 
     desc :images, 'Describe machine images owned by Breeze::CONFIGURATION[:image_owner]'
@@ -72,5 +74,20 @@ module Breeze
         zone.records.map{ |r| [r.name, r.type, r.ttl, r.ip.join(', ')] }
     end
 
+    desc :cache_clusters, 'Describe ElastiCache clusters'
+    def cache_clusters
+      report 'CACHE CLUSTERS',
+        ['Name', 'Type', 'Engine', 'Nodes', 'Status'],
+        elasticache.clusters.map{ |c| [c.id, c.node_type, c.engine, c.num_nodes, c.status] }
+        # c.nodes[0]['Address']
+    end
+
+    desc :load_balancers, 'Describe ELB load balancers'
+    def load_balancers
+      report 'ELASTIC LOAD BALANCERS',
+        ['Name', 'DNS name', 'Availability zones', 'Instances'],
+        elb.load_balancers.map{ |lb| [lb.id, lb.dns_name, lb.availability_zones.join(', '), lb.instances.join(', ')] }
+    end
+
   end
 end

data/lib/breeze/tasks/elasticache.rb

@@ -0,0 +1,24 @@
+module Breeze
+
+  class Elasticache < Veur
+
+    desc 'create CLUSTER_NAME', 'Create a new cache cluster'
+    method_options CONFIGURATION[:default_elasticache_options]
+    def create(name)
+      options.update(:id => name)
+      # puts "elasticache options: #{options}"
+      elasticache.clusters.create(options)
+    end
+
+    desc 'destroy CLUSTER_NAME', 'Destroy a cache cluster'
+    method_options :force => false
+    def destroy(name)
+      cluster = elasticache.clusters.get(name)
+      if force_or_accept?("Destroy cache cluster #{name}?")
+        cluster.destroy
+        cluster.reload
+      end
+    end
+
+  end
+end

data/lib/breeze/tasks/elb.rb

@@ -0,0 +1,40 @@
+module Breeze
+
+  class Elb < Veur
+
+    desc 'create LOAD_BALANCER_NAME [CNAME] [DNS_ZONE_ID]', 'Create a new elastic load balancer'
+    method_options :dns_ttl => 60
+    def create(name, cname=nil, dns_zone_id=nil)
+      conf = CONFIGURATION[:elb]
+      response = elb.create_load_balancer(conf[:instances].map{ |i| i[:availability_zone] }.uniq, name, conf[:listeners])
+      if cname
+        thor("dns:record:create #{dns_zone_id} #{cname}. CNAME #{response.body['CreateLoadBalancerResult']['DNSName']} #{options[:dns_ttl]}")
+      end
+      elb.configure_health_check(name, conf[:health_check])
+    end
+
+    desc 'add_instances LOAD_BALANCER_NAME instance_id [instance_id, ...]', 'Add server instances to a load balancer'
+    def add_instances(name, *instance_ids)
+      elb.register_instances(instance_ids, name)
+    end
+
+    desc 'remove_instances LOAD_BALANCER_NAME instance_id [instance_id, ...]', 'Remove server instances from a load balancer'
+    def remove_instances(name, *instance_ids)
+      elb.deregister_instances(instance_ids, name)
+    end
+
+    desc 'destroy LOAD_BALANCER_NAME', 'Destroy an elastic load balancer'
+    method_options :force => false
+    def destroy(name, cname=nil, dns_zone_id=nil)
+      load_balancer = elb.load_balancers.get(name)
+      if force_or_accept?("Destroy load balancer #{name}?")
+        load_balancer.destroy
+        if cname
+          thor("dns:record:destroy #{dns_zone_id} #{cname}. CNAME --force")
+        end
+        load_balancer.reload
+      end
+    end
+
+  end
+end

data/lib/breeze/veur.rb

@@ -86,5 +86,13 @@ module Breeze
       @rds ||= Breeze::FogWrapper.connection(:rds)
     end
 
+    def elasticache
+      @elasticache ||= Breeze::FogWrapper.connection(:elasticache)
+    end
+
+    def elb
+      @elb ||= Breeze::FogWrapper.connection(:elb)
+    end
+
   end
 end

data/lib/templates/Thorfile

@@ -54,6 +54,45 @@ Breeze::CONFIGURATION = {
     :password => 'admin'
   },
 
+  # elasticache configuration is required in order to use Amazon ElastiCache
+  :default_elasticache_options => {
+    :node_type                    => 'cache.t1.micro',
+    :security_group_names         => '',
+    :num_nodes                    => 1,
+    :auto_minor_version_upgrade   => true,
+    :engine                       => 'memcached',
+    :engine_version               => '',
+    :port                         => '',
+    :preferred_availablility_zone => ''
+  },
+
+  # ELB configuration is required in order to use Amazon Elastic Load Balancing
+  :elb => {
+    :instances => [
+      {availability_zone: 'us-east-1a', flavor_id: 't1.micro', count: 1},
+      {availability_zone: 'us-east-1d', flavor_id: 't1.micro', count: 1}
+    ],
+    :listeners => [{
+      'Protocol' => 'HTTP',
+      'LoadBalancerPort' => 80,
+      'InstancePort' => 80,
+      'InstanceProtocol' => 'HTTP'
+    }, {
+      'Protocol' => 'HTTPS',
+      'LoadBalancerPort' => 443,
+      'InstancePort' => 80,
+      'InstanceProtocol' => 'HTTP',
+      'SSLCertificateId' => 'arn:aws:iam::....'
+    }],
+    :health_check => {
+      'Target' => 'HTTP:80/ping',
+      'Interval' => 20,
+      'Timeout' => 4,
+      'HealthyThreshold' => 3,
+      'UnhealthyThreshold' => 2
+    }
+  },
+
   # you can add your own keys and access this hash as CONFIGURATION in the erb templates
   :admin_email => 'YOUR-EMAIL',
   :app_path => '/srv/YOUR-APP'

metadata

@@ -1,89 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: breeze
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Markus Bengts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-28 00:00:00.000000000 Z
+date: 2014-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: aruba
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! 'Breeze makes it easy to automate server installation and configuration.
-  It provides
-
+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.
-
-'
+  control system. Thor tasks are provided to create server images, launch server instances etc.
 email:
 - markus.bengts@gmail.com
 executables:
@@ -91,8 +77,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rbenv-version
+- ".gitignore"
+- ".ruby-version"
 - Gemfile
 - LICENSE
 - README.md
@@ -117,6 +103,8 @@ files:
 - lib/breeze/tasks/db.rb
 - lib/breeze/tasks/describe.rb
 - lib/breeze/tasks/dns.rb
+- lib/breeze/tasks/elasticache.rb
+- lib/breeze/tasks/elb.rb
 - lib/breeze/tasks/server.rb
 - lib/breeze/tasks/server/address.rb
 - lib/breeze/tasks/server/image.rb
@@ -141,33 +129,26 @@ files:
 - lib/templates/user_data.sh
 homepage: https://github.com/markus/breeze
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4461246332485121240
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 4461246332485121240
 requirements: []
 rubyforge_project: breeze
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Thor tasks to manage cloud computing resources and deployments
 test_files:
 - features/dns.feature

data/.rbenv-version

@@ -1 +0,0 @@
-1.9.3-p286