breeze 0.0.1

data/lib/breeze/tasks/dns.rb

@@ -0,0 +1,67 @@
+module Breeze
+  module Dns
+
+    class Zone < Veur
+
+      desc 'create DOMAIN', 'Create a new DNS zone'
+      def create(domain)
+        zone = dns.zones.create(:domain => domain)
+        puts "Zone ID: #{zone.id}"
+        puts "Change info: #{zone.change_info}"
+        puts "Name servers: #{zone.nameservers}"
+      end
+
+      desc 'destroy ZONE_ID', 'Destroy a DNS zone'
+      def destroy(zone_id)
+        zone = dns.zones.get(zone_id)
+        if accept?("Destroy DNS zone and records for #{zone.domain}?")
+          zone.records.each(&:destroy)
+          zone.destroy
+        end
+      end
+
+      desc 'import ZONE_ID FILE', 'Creates dns records specified in FILE'
+      long_desc <<-END_DESC
+        FILE should be the path to a ruby file that defines DNS_RECORDS like this:
+        DNS_RECORDS = [
+          {:name => 'example.com', :type => 'A', :ip => '1.2.3.4'},
+          {:name => 'www.example.com', :type => 'CNAME', :ip => 'example.com'}
+        ]
+        You can also specify :ttl for each record. The default ttl is 3600 (1 hour).
+      END_DESC
+      def import(zone_id, file)
+        load file
+        zone = get_zone(zone_id)
+        DNS_RECORDS.each do |record_hash|
+          zone.records.create(record_hash)
+          puts record_hash.inspect
+        end
+      end
+
+      private
+
+      def get_zone(id)
+        dns.zones.get(id)
+      end
+
+    end
+
+    class Record < Zone
+
+      desc 'create ZONE_ID NAME TYPE IP [TTL]', 'Create a new DNS record'
+      def create(zone_id, name, type, ip, ttl=3600)
+        get_zone(zone_id).records.create(:name => name, :type => type, :ip => ip, :ttl => ttl)
+      end
+
+      desc 'destroy ZONE_ID NAME [TYPE]', 'Destroy a DNS record'
+      method_options :force => false
+      def destroy(zone_id, name, type=nil)
+        records = get_zone(zone_id).records.select{ |r| r.name == name && (type.nil? || r.type == type) }
+        if force_or_accept?("Destroy #{records.size} record#{records.size == 1 ? '' : 's'}?")
+          records.each(&:destroy)
+        end
+      end
+
+    end
+  end
+end

data/lib/breeze/tasks/list.rb

@@ -0,0 +1,74 @@
+module Breeze
+
+  class List < Veur
+
+    desc :cloud_resources, 'List all cloud resources that the current account can control with breeze'
+    def cloud_resources
+      images
+      servers
+      addresses
+      volumes
+      db_servers
+      dns_zones
+    end
+
+    desc :images, 'Describe machine images owned by Breeze::CONFIGURATION[:image_owner]'
+    def images
+      report 'MACHINE IMAGES',
+        ['Name or Location', 'Image ID', 'Owner', 'Image Type', 'Public'],
+        fog.images.all('Owner' => Breeze::CONFIGURATION[:image_owner]).map{ |i|
+          [i.name||i.location, i.id, i.owner_id, i.full_type, i.is_public]
+        }
+    end
+
+    desc :servers, 'Describe server instances'
+    def servers
+      report "SERVER INSTANCES",
+        ['Name', 'Instance ID', 'IP Address', 'Image ID', 'Instance Type', 'Availability Zone', 'State'],
+        fog.servers.map { |i|
+          [i.name, i.id, i.public_ip_address, i.image_id, i.flavor_id, i.availability_zone, i.state]
+        }
+    end
+
+    desc :addresses, 'List allocated ip addresses'
+    def addresses
+      report "ALLOCATED IP ADDRESSES",
+        ['Address', 'Server'],
+        fog.addresses.map{ |a| [a.public_ip, a.server_id] }
+    end
+
+    desc :volumes, 'Describe block store volumes (EBS)'
+    def volumes
+      report "VOLUMES",
+        ['Volume ID', 'Size', 'Status', 'Zone', 'Snapshot ID', 'Used by'],
+        fog.volumes.map { |v|
+          [v.id, v.size, v.state, v.availability_zone, v.snapshot_id, v.server_id]
+        }
+    end
+
+    desc :db_servers, 'List database servers'
+    def db_servers
+      report "DATABASE SERVERS",
+        ['Name', 'Type', 'Storage', 'State', 'Endpoint'],
+        rds.servers.map{ |s| [s.id, s.flavor_id, s.allocated_storage, s.state, s.endpoint] }
+    end
+
+    desc :dns_zones, 'Describe DNS zones'
+    def dns_zones
+      zones = dns.zones
+      zones.each(&:reload) # necessary in order to get nameservers
+      report "DNS ZONES",
+        ['Domain', 'Zone ID', 'Name servers'],
+        zones.map{ |z| [z.domain, z.id, z.nameservers.join(', ')] }
+    end
+
+    desc 'dns_records ZONE_ID', 'List all DNS records for the given zone'
+    def dns_records(zone_id)
+      zone = dns.zones.get(zone_id)
+      report "DNS RECORDS FOR #{zone.domain}",
+        ['Name', 'Type', 'TTL', 'Value'],
+        zone.records.map{ |r| [r.name, r.type, r.ttl, r.ip.join(', ')] }
+    end
+
+  end
+end

data/lib/breeze/tasks/server.rb

@@ -0,0 +1,72 @@
+require 'resolv'
+
+module Breeze
+
+  # Dealing with server instances.
+  class Server < Veur
+
+    desc 'create', 'Launch a new server instance'
+    method_options CONFIGURATION[:default_server_options]
+    def create
+      if options[:user_data_file]
+        options[:user_data] = Base64.encode64(File.read(options[:user_data_file])).strip
+      end
+      create_server(options)
+    end
+
+    desc 'destroy INSTANCE_ID', 'Terminate a running (or stopped) server instance'
+    method_options :force => false
+    def destroy(instance_id)
+      server = fog.servers.get(instance_id)
+      if force_or_accept?("Terminate server #{server.display_name}?")
+        server.destroy
+      end
+    end
+
+    private
+
+    def create_server(options=nil)
+      options ||= CONFIGURATION[:default_server_options]
+      # puts("Server options: #{options.inspect}")
+      server = fog.servers.create(options)
+      print "Launching server #{server.id}"
+      wait_until('running!') { server.running? }
+      return server
+    end
+
+    def wait_until_host_is_available(host)
+      if Resolv.getaddresses(host).empty?
+        print("Waiting for #{host} to resolve")
+        wait_until('ready!') { Resolv.getaddresses(host).any? }
+      end
+      return true if remote_is_available?(host)
+      print("Waiting for #{host} to accept connections")
+      wait_until('ready!') { remote_is_available?(host) }
+    end
+
+    def remote_is_available?(host)
+      execute(:remote_command, :command => 'exit', :host => host)
+    end
+
+    def remote(command, args)
+      args[:command] = command
+      execute(:remote_command, args)
+    end
+
+    def upload(file_pattern, args)
+      args[:file_pattern] = file_pattern
+      execute(:upload_command, args)
+    end
+
+    def execute(command, args)
+      command = CONFIGURATION[command] if command.is_a?(Symbol)
+    #   system(command % args)
+    # rescue ArgumentError # for ruby 1.8 compatibility
+      args.each do |key, value|
+        command = command.gsub("%{#{key}}", value)
+      end
+      system(command)
+    end
+
+  end
+end

data/lib/breeze/tasks/server/address.rb

@@ -0,0 +1,27 @@
+module Breeze
+
+  # Aka Amazon Elastic IP
+  class Server::Address < Veur
+
+    desc 'create SERVER_ID', 'Create and associate a new elastic ip'
+    def create(server_id)
+      # TODO: fog should take server_id directly when creating an address
+      server = fog.servers.get(server_id)
+      fog.addresses.create(:server => server)
+    end
+
+    desc 'release IP', 'Release the ip address'
+    method_options :force => false
+    def release(ip)
+      if force_or_accept?("Release IP #{ip}?")
+        fog.addresses.get(ip).destroy
+      end
+    end
+
+    desc 'associate IP NEW_SERVER_ID', 'Associate an existing IP with a new server'
+    def associate(ip, server_id)
+      fog.associate_address(server_id, ip)
+    end
+
+  end
+end

data/lib/breeze/tasks/server/image.rb

@@ -0,0 +1,27 @@
+require 'breeze/tasks/server'
+
+module Breeze
+
+  # Dealing with machine images.
+  class Server::Image < Server
+    desc '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.'
+    method_options CONFIGURATION[:default_server_options].merge(CONFIGURATION[:create_image_options])
+    def create
+      options[:block_device_mapping] = [{:device_name => '/dev/sda1', :ebs_volume_size => options.delete(:root_device_size)}]
+      server = create_server(options)
+      prepare_private_image(server.public_ip_address)
+      print('Stopping the server before saving a snapshot')
+      server.stop
+      wait_until('stopped!') { server.stopped? }
+      thor('list:images')
+      image = fog.images.create(:name => ask('Image name >'), :instance_id => server.id)
+      server.destroy
+      puts
+      puts("===> Created image #{image.id} and terminated temporary server #{server.id}.")
+      puts
+      puts("NOTICE: it may take a while before the new image shows up in list:images")
+    end
+
+  end
+end

data/lib/breeze/tasks/server/tag.rb

@@ -0,0 +1,16 @@
+module Breeze
+
+  class Server::Tag < Veur
+
+    desc 'create SERVER_ID KEY VALUE', 'Create or update a tag'
+    def create(server_id, key, value)
+      fog.tags.create(:resource_id => server_id, :key => key, :value => value)
+    end
+
+    desc 'destroy SERVER_ID KEY', 'Delete a tag'
+    def destroy(server_id, key)
+      fog.tags.get(key).detect{ |tag| tag.resource_id == server_id }.destroy
+    end
+
+  end
+end

data/lib/breeze/veur.rb

@@ -0,0 +1,86 @@
+require 'breeze/fog_extensions'
+
+module Breeze
+
+  # Thor is also known as Veur. Veur means "guard of the shrine"
+  # (possibly) according to Wikipedia.
+  class Veur < Thor
+
+    include Thor::Actions
+
+    # shorten the task names
+    def self.inherited(c)
+      c.class_eval do
+        namespace Thor::Util.namespace_from_thor_class(c).sub('breeze:', '')
+      end
+    end
+
+    private
+
+    # Thor freezes the options (don't understand why)
+    def options
+      @unfrozen_options ||= super.dup
+    end
+
+    # yes? in thor cannot be accepted with enter
+    def accept?(question)
+      ! (ask("#{question} [YES/no] >") =~ /n/i)
+    end
+
+    # don't ask questions if given the --force option
+    def force_or_accept?(question)
+      options[:force] or accept?(question)
+    end
+
+    # Print out dots while waiting for something.
+    # Usage:
+    #   print "My task is running..."
+    #   wait_until { my_task.completed? }
+    def wait_until(message='completed!')
+      3.times { dot_and_sleep(1) }
+      dot_and_sleep(2) until yield
+      puts message
+    end
+
+    # a helper for wait_until
+    def dot_and_sleep(interval)
+      print('.')
+      sleep(interval)
+    end
+
+    # Print a table with a title and a top border of matching width.
+    def report(title, columns, rows)
+      table = capture_table([columns] + rows)
+      title = "=== #{title} "
+      title << "=" * [(table.lines.max{|s| s.size }.size - title.size), 3].max
+      puts title
+      puts table
+    end
+
+    # capture table in order to determine it's width
+    def capture_table(table)
+      return 'none' if table.size == 1 # the first row is for column titles
+      $stdout = StringIO.new  # start capturing the output
+      print_table(table.map{ |row| row.map(&:to_s) })
+      output = $stdout
+      $stdout = STDOUT        # restore normal output
+      return output.string
+    end
+
+    def fog
+      @fog ||= Fog::Compute.new(CONFIGURATION[:cloud_service])
+    end
+
+    def dns
+      @dns ||= Fog::DNS.new(CONFIGURATION[:cloud_service])
+    end
+
+    def rds
+      return @rds if @rds
+      credentials = CONFIGURATION[:cloud_service].reject{ |k,v| k == :provider }
+      credentials[:region] = CONFIGURATION[:db_region]
+      @rds = Fog::AWS::RDS.new(credentials)
+    end
+
+  end
+end

data/lib/templates/Thorfile

@@ -0,0 +1,122 @@
+# Sign up for AWS credentials at http://aws.amazon.com/, and learn how to
+# upload your own public ssh key at http://alestic.com/2010/10/ec2-ssh-keys.
+# Use environment variables in this file if you share it with others.
+
+require 'breeze'
+
+Breeze::CONFIGURATION = {
+
+  # Access credentials are needed for all tasks.
+  :cloud_service => {
+    :provider => 'AWS',
+    :aws_access_key_id => 'YOUR-ACCESS-KEY-ID',
+    :aws_secret_access_key => 'YOUR-SECTET-ACCESS-KEY'
+  },
+
+  # Remote and upload commands are required in order to create a server image or deploy
+  # an application. Arguments marked with %{} are automatically replaced when the
+  # commands are used. Use "ssh -i /path/to/key" if not using your default ssh key.
+  :remote_command => "ssh ubuntu@%{host} '%{command}'",
+  :upload_command => 'rsync -v %{file_pattern} ubuntu@%{host}:%{remote_path}',
+
+  # :rollback_window specifies the number of minutes to keep old instances running after new ones
+  # have been deployed. Rollback is no longer possible when the old instances have been destroyed.
+  :rollback_window => 60,
+
+  # Default server options are needed when launching new servers.
+  :default_server_options => {
+    :image_id           => 'YOUR-PRIVATE-AMI-OR-A-PUBLIC-ONE',
+    :key_name           => 'THE-NAME-OF-YOUR-KEYPAIR', # http://alestic.com/2010/10/ec2-ssh-keys
+    :flavor_id          => 't1.micro', # t1.micro m1.small c1.medium ...
+    :availability_zone  => 'us-east-1a', # us-west-1a eu-west-1a ap-southeast-1a
+    :user_data_file     => nil
+  },
+
+  # Override default_server_options when building your own private server image:
+  :create_image_options => {
+    :image_id => 'ami-ccf405a5', # a base AMI from http://alestic.com
+    :root_device_size => 15 # in GB
+  },
+
+  # machine images owned by this account are included in list:images (provided that you have access to them)
+  :image_owner => 'YOUR-ACCOUNT-ID-WITHOUT-DASHES', # canonical: '099720109477'
+
+  # db configuration is required in order to use Amazon RDS
+  :db_region => 'us-east-1', # us-west-1 eu-west-1 ap-southeast-1
+  :default_db_options => {
+    :engine => 'mysql',
+    :engine_version => '5.5',
+    :auto_minor_version_upgrade => true,
+    :allocated_storage => 5, # 5 - 1024 GB
+    :availability_zone => 'us-east-1a',
+    :backup_retention_period => 1, # 0 - 8 days
+    :preferred_backup_window => '05:30-06:00', # daily, times in UTC
+    :preferred_maintenance_window => 'sun:06:00-sun:06:30', # weekly
+    :master_username => 'admin',
+    :password => 'admin'
+  },
+
+  # 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'
+}.freeze
+
+# Define Breeze::CONFIGURATION before requiring the tasks.
+# This allows us to pick up default options that can be viewed
+# with the "thor help" command.
+require 'breeze/tasks'
+
+class Breeze::Server::Image
+  private
+  # This method is called from server:image:create. Modify this and/or the scripts that
+  # are uploaded in order to create your own private machine image.
+  def prepare_private_image(ip_address)
+    wait_until_host_is_available(ip_address)
+    puts("Uploading scripts...")
+    upload('config/breeze/scripts/*.sh', :host => ip_address, :remote_path => './')
+    remote('chmod 600 credentials.sh; chmod 700 deploy.sh; bash install.sh', :host => ip_address)
+  end
+end
+
+# You can define staging:start etc. with fixed parameters below.
+
+class Breeze::App
+  private
+  def deploy_command(servers, public_server_name, db_server_name, branch)
+    servers.each do |server|
+      wait_until_host_is_available(ip(server))
+      remote("/home/ubuntu/deploy.sh #{public_server_name} #{db_endpoint(db_server_name)} #{branch}", :host => ip(server))
+    end
+  end
+end
+
+# thor staging:start and staging:stop
+class Staging < Breeze::App
+
+  PUBLIC_SERVER_NAME = 'staging.example.com'
+  DB_SERVER_NAME = 'staging-db'
+
+  desc 'start', 'Start web server and db for staging'
+  def start
+    thor("app:start #{PUBLIC_SERVER_NAME} #{DB_SERVER_NAME} --db-to-clone=#{Production::DB_SERVER_NAME} --deploy-branch=master")
+  end
+
+  desc 'stop', 'Stop staging and destroy server and db'
+  def stop
+    thor("app:stop #{PUBLIC_SERVER_NAME} --force")
+  end
+
+end
+
+# thor production:start
+class Production < Breeze::App
+
+  PUBLIC_SERVER_NAME = 'production.example.com'
+  DB_SERVER_NAME = 'production-db'
+
+  desc 'start', 'Start web server and db for production'
+  def start
+    thor("app:start #{PUBLIC_SERVER_NAME} #{DB_SERVER_NAME} crags --dns-ttl=300 --deploy-branch=stable")
+  end
+
+end