wr0ngway-rubber 1.0.0

data/lib/rubber/cloud/aws.rb

@@ -0,0 +1,305 @@
+require 'rubygems'
+require 'AWS'
+require 'aws/s3'
+
+module Rubber
+  module Cloud
+
+    class Aws < Base
+
+      def initialize(env, capistrano)
+        super(env, capistrano)
+        @aws_env = env.cloud_providers.aws
+        @ec2 = AWS::EC2::Base.new(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
+        @ec2elb = AWS::ELB::Base.new(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
+        AWS::S3::Base.establish_connection!(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
+      end
+
+
+      def create_instance(ami, ami_type, security_groups, availability_zone)
+        response = @ec2.run_instances(:image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :group_id => security_groups, :availability_zone => availability_zone)
+        instance_id = response.instancesSet.item[0].instanceId
+        return instance_id
+      end
+
+      def describe_instances(instance_id=nil)
+        instances = []
+        opts = {}
+        opts[:instance_id] = instance_id if instance_id
+
+        response = @ec2.describe_instances(opts)
+        response.reservationSet.item.each do |ritem|
+          ritem.instancesSet.item.each do |item|
+            instance = {}
+            instance[:id] = item.instanceId
+            instance[:external_host] = item.dnsName
+            instance[:external_ip] = IPSocket.getaddress(instance[:external_host]) rescue nil
+            instance[:internal_host] = item.privateDnsName
+            instance[:state] = item.instanceState.name
+            instance[:zone] = item.placement.availabilityZone
+            instances << instance
+          end
+        end if response.reservationSet
+
+        return instances
+      end
+
+      def destroy_instance(instance_id)
+        response = @ec2.terminate_instances(:instance_id => instance_id)
+      end
+
+      def describe_availability_zones
+        zones = []
+        response = @ec2.describe_availability_zones()
+        response.availabilityZoneInfo.item.each do |item|
+          zone = {}
+          zone[:name] = item.zoneName
+          zone[:state] =item.zoneState
+          zones << zone
+        end if response.availabilityZoneInfo
+        return zones
+      end
+
+      def create_security_group(group_name, group_description)
+        @ec2.create_security_group(:group_name => group_name, :group_description => group_description)
+      end
+
+      def describe_security_groups(group_name=nil)
+        groups = []
+
+        opts = {}
+        opts[:group_name] = group_name if group_name
+        response = @ec2.describe_security_groups(opts)
+
+        response.securityGroupInfo.item.each do |item|
+          group = {}
+          group[:name] = item.groupName
+          group[:description] = item.groupDescription
+
+          item.ipPermissions.item.each do |ip_item|
+            group[:permissions] ||= []
+            rule = {}
+
+            rule[:protocol] = ip_item.ipProtocol
+            rule[:from_port] = ip_item.fromPort
+            rule[:to_port] = ip_item.toPort
+
+            ip_item.groups.item.each do |rule_group|
+              rule[:source_groups] ||= []
+              source_group = {}
+              source_group[:account] = rule_group.userId
+              source_group[:name] = rule_group.groupName
+              rule[:source_groups] << source_group
+            end if ip_item.groups
+
+            ip_item.ipRanges.item.each do |ip_range|
+              rule[:source_ips] ||= []
+              rule[:source_ips] << ip_range.cidrIp
+            end if ip_item.ipRanges
+
+            group[:permissions] << rule
+          end if item.ipPermissions
+
+          groups << group
+          
+        end if response.securityGroupInfo
+
+        return groups
+      end
+
+      def add_security_group_rule(group_name, protocol, from_port, to_port, source)
+        opts = {:group_name => group_name}
+        if source.instance_of? Hash
+          opts = opts.merge(:source_security_group_name => source[:name], :source_security_group_owner_id => source[:account])
+        else
+          opts = opts.merge(:ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => source)
+        end
+        @ec2.authorize_security_group_ingress(opts)
+      end
+
+      def remove_security_group_rule(group_name, protocol, from_port, to_port, source)
+        opts = {:group_name => group_name}
+        if source.instance_of? Hash
+          opts = opts.merge(:source_security_group_name => source[:name], :source_security_group_owner_id => source[:account])
+        else
+          opts = opts.merge(:ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => source)
+        end
+        @ec2.revoke_security_group_ingress(opts)
+      end
+
+      def destroy_security_group(group_name)
+        @ec2.delete_security_group(:group_name => group_name)
+      end
+
+      def create_static_ip
+        response = @ec2.allocate_address()
+        return response.publicIp
+      end
+
+      def attach_static_ip(ip, instance_id)
+        response = @ec2.associate_address(:instance_id => instance_id, :public_ip => ip)
+        return response.return == "true"
+      end
+
+      def detach_static_ip(ip)
+        response = @ec2.disassociate_address(:public_ip => ip)
+        return response.return == "true"
+      end
+
+      def describe_static_ips(ip=nil)
+        ips = []
+        opts = {}
+        opts[:public_ip] = ip if ip
+        response = @ec2.describe_addresses(opts)
+        response.addressesSet.item.each do |item|
+          ip = {}
+          ip[:instance_id] = item.instanceId
+          ip[:ip] = item.publicIp
+          ips << ip
+        end if response.addressesSet
+        return ips
+      end
+
+      def destroy_static_ip(ip)
+        response = @ec2.release_address(:public_ip => ip)
+        return response.return == "true"
+      end
+
+      def create_volume(size, zone)
+        response = @ec2.create_volume(:size => size.to_s, :availability_zone => zone)
+        return response.volumeId
+      end
+
+      def attach_volume(volume_id, instance_id, device)
+        response = @ec2.attach_volume(:volume_id => volume_id, :instance_id => instance_id, :device => device)
+        return response.status
+      end
+
+      def detach_volume(volume_id)
+        @ec2.detach_volume(:volume_id => volume_id, :force => 'true')
+      end
+
+      def describe_volumes(volume_id=nil)
+        volumes = []
+        opts = {}
+        opts[:volume_id] = volume_id if volume_id
+        response = @ec2.describe_volumes(opts)
+        response.volumeSet.item.each do |item|
+          volume = {}
+          volume[:id] = item.volumeId
+          volume[:status] = item.status
+          if item.attachmentSet
+            attach = item.attachmentSet.item[0]
+            volume[:attachment_instance_id] = attach.instanceId
+            volume[:attachment_status] = attach.status
+          end
+          volumes << volume
+        end if response.volumeSet
+        return volumes
+      end
+
+      def destroy_volume(volume_id)
+        @ec2.delete_volume(:volume_id => volume_id)
+      end
+
+      def create_image(image_name)
+        ec2_key = @aws_env.key_file
+        ec2_pk = @aws_env.pk_file
+        ec2_cert = @aws_env.cert_file
+        ec2_key_dest = "/mnt/#{File.basename(ec2_key)}"
+        ec2_pk_dest = "/mnt/#{File.basename(ec2_pk)}"
+        ec2_cert_dest = "/mnt/#{File.basename(ec2_cert)}"
+
+        capistrano.put(File.read(ec2_key), ec2_key_dest)
+        capistrano.put(File.read(ec2_pk), ec2_pk_dest)
+        capistrano.put(File.read(ec2_cert), ec2_cert_dest)
+
+        arch = capistrano.capture "uname -m"
+        arch = case arch when /i\d86/ then "i386" else arch end
+
+        capistrano.sudo_script "create_bundle", <<-CMD
+          export RUBYLIB=/usr/lib/site_ruby/
+          nohup ec2-bundle-vol --batch -d /mnt -k #{ec2_pk_dest} -c #{ec2_cert_dest} -u #{@aws_env.account} -p #{image_name} -r #{arch}  &> /tmp/ec2-bundle-vol.log &
+          echo "Creating image from instance volume..."
+          while true; do
+            if ! ps ax | grep -q "[e]c2-bundle-vol"; then exit; fi
+            echo -n .
+            sleep 1
+          done
+        CMD
+
+        capistrano.sudo_script "register_bundle", <<-CMD
+          export RUBYLIB=/usr/lib/site_ruby/
+          echo "Uploading image to S3..."
+          ec2-upload-bundle --batch -b #{@aws_env.image_bucket} -m /mnt/#{image_name}.manifest.xml -a #{@aws_env.access_key} -s #{@aws_env.secret_access_key}
+        CMD
+
+        image_location = "#{@aws_env.image_bucket}/#{image_name}.manifest.xml"
+        response = @ec2.register_image(:image_location => image_location)
+        return response.imageId
+      end
+
+      def describe_images(image_id=nil)
+        images = []
+        opts = {:owner_id => 'self'}
+        opts[:image_id] = image_id if image_id
+        response = @ec2.describe_images(opts)
+        response.imagesSet.item.each do |item|
+          image = {}
+          image[:id] = item.imageId
+          image[:location] = item.imageLocation
+          images << image
+        end if response.imagesSet
+        return images
+      end
+
+      def destroy_image(image_id)
+        image = describe_images(image_id).first
+        image_location = image[:location]
+        bucket = image_location.split('/').first
+        image_name = image_location.split('/').last.gsub(/\.manifest\.xml$/, '')
+
+        @ec2.deregister_image(:image_id => image_id)
+
+        s3_bucket = AWS::S3::Bucket.find(bucket)
+        s3_bucket.objects(:prefix => image_name).clone.each do |obj|
+          obj.delete
+        end
+        if s3_bucket.empty?
+          s3_bucket.delete
+        end
+      end
+
+      def describe_load_balancers(name=nil)
+        lbs = []
+        opts = {}
+        opts[:load_balancer_names] = name if name
+        response = @ec2elb.describe_load_balancers(opts)
+        response.describeLoadBalancersResult.member.each do |member|
+          lb = {}
+          lb[:name] = member.loadBalancerName
+          lb[:dns_name] = member.dNSName
+
+          member.availabilityZones.member.each do |zone|
+            lb[:zones] ||= []
+            lb[:zones] << zone
+          end
+
+          member.listeners.member.each do |member|
+            listener = {}
+            listener[:protocol] = member.protocol
+            listener[:port] = member.loadBalancerPort
+            listener[:instance_port] = member.instancePort
+            lb[:listeners] ||= []
+            lb[:listeners] << listener
+          end
+
+          lbs << lb
+        end if response.describeLoadBalancersResult
+        return lbs
+      end
+
+    end
+
+  end
+end

data/lib/rubber/cloud/base.rb

@@ -0,0 +1,16 @@
+module Rubber
+  module Cloud
+
+    class Base
+
+      attr_reader :env, :capistrano
+
+      def initialize(env, capistrano)
+        @env = env
+        @capistrano = capistrano
+      end
+
+    end
+
+  end
+end

data/lib/rubber/cloud.rb

@@ -0,0 +1,13 @@
+require "rubber/cloud/base"
+
+module Rubber
+  module Cloud
+
+    def self.get_provider(provider, env, capistrano)
+      require "rubber/cloud/#{provider}"
+      clazz = Rubber::Cloud.const_get(provider.capitalize)
+      return clazz.new(env, capistrano)
+    end
+
+  end
+end

data/lib/rubber/configuration.rb

@@ -0,0 +1,47 @@
+require 'logger'
+require 'rubber/environment'
+require 'rubber/instance'
+require 'rubber/generator'
+
+module Rubber
+  module Configuration
+
+    @@configurations = {}
+
+    def self.get_configuration(env=nil, root=nil)
+      key = "#{env}-#{root}"
+      @@configurations[key] ||= ConfigHolder.new(env, root)
+    end
+
+    def self.rubber_env
+      raise "This convenience method needs RUBBER_ENV to be set" unless RUBBER_ENV
+      cfg = Rubber::Configuration.get_configuration(RUBBER_ENV)
+      host = cfg.environment.current_host
+      roles = cfg.instance[host].role_names rescue nil
+      cfg.environment.bind(roles, host)
+    end
+
+    def self.rubber_instances
+      raise "This convenience method needs RUBBER_ENV to be set" unless RUBBER_ENV
+      Rubber::Configuration.get_configuration(RUBBER_ENV).instance
+    end
+
+    class ConfigHolder
+      def initialize(env=nil, root=nil)
+        root = "#{RUBBER_ROOT}/config/rubber" unless root
+        instance_cfg =  "#{root}/instance" + (env ? "-#{env}.yml" : ".yml")
+        @environment = Environment.new("#{root}")
+        @instance = Instance.new(instance_cfg)
+      end
+
+      def environment
+        @environment
+      end
+
+      def instance
+        @instance
+      end
+    end
+
+  end
+end

data/lib/rubber/dns/base.rb

@@ -0,0 +1,69 @@
+module Rubber
+  module Dns
+
+    class Base
+
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def update(host, ip)
+        if up_to_date(host, ip)
+          puts "IP has not changed for #{host}, not updating dynamic DNS"
+        else
+          if ! host_exists?(host)
+            puts "Creating dynamic DNS: #{host} => #{ip}"
+            create_host_record(host, ip)
+          else
+            puts "Updating dynamic DNS: #{host} => #{ip}"
+            update_host_record(host, ip)
+          end
+        end
+      end
+
+      def destroy(host)
+        if host_exists?(host)
+          puts "Destroying dynamic DNS record: #{host}"
+          destroy_host_record(host)
+        end
+      end
+
+      def hostname(host)
+        "#{host}.#{@env.domain}"
+      end
+
+      def up_to_date(host, ip)
+        # This queries dns server directly instead of using hosts file
+        current_ip = nil
+        Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
+          current_ip = dns.getaddress(hostname(host)).to_s rescue nil
+        end
+        return ip == current_ip
+      end
+
+      def nameserver()
+        raise "nameserver not implemented"
+      end
+
+      def host_exists?(host)
+        raise "host_exists? not implemented"
+      end
+
+      def create_host_record(host, ip)
+        raise "create_host_record not implemented"
+      end
+
+      def destroy_host_record(host)
+        raise "destroy_host_record not implemented"
+      end
+
+      def update_host_record(host, ip)
+        raise "update_host_record not implemented"
+      end
+
+    end
+
+  end
+end

data/lib/rubber/dns/dyndns.rb

@@ -0,0 +1,63 @@
+module Rubber
+  module Dns
+
+    class Dyndns < Base
+
+      def initialize(env)
+        super(env)
+        @dyndns_env = env.dns_providers.dyndns
+        @user, @pass = @dyndns_env.user, @dyndns_env.password
+        @update_url = @dyndns_env.update_url || 'https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
+        @update_url = @update_url.gsub(/%([^%]+)%/, '#{\1}')
+      end
+
+      def nameserver
+        "ns1.mydyndns.org"
+      end
+
+      def host_exists?(host)
+        begin
+          Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
+            dns.getresource(hostname(host), Resolv::DNS::Resource::IN::A)
+          end
+        rescue
+          raise "Domain needs to exist in dyndns as an A record before record can be updated"
+        end
+        return true
+      end
+
+      def create_host_record(host, ip)
+        puts "WARNING: No create record available for dyndns, you need to do so manually"
+      end
+
+      def destroy_host_record(host)
+        puts "WARNING: No destroy record available for dyndns, you need to do so manually"
+      end
+
+      def update_host_record(host, ip)
+        host = hostname(host)
+        update_url = eval('%Q{' + @update_url + '}')
+
+        # This header is required by dyndns.org
+        headers = {
+         "User-Agent" => "Capistrano - Rubber - 0.1"
+        }
+
+        uri = URI.parse(update_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        # switch on SSL
+        http.use_ssl = true if uri.scheme == "https"
+        # suppress verification warning
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        req = Net::HTTP::Get.new(update_url.gsub(/.*:\/\/[^\/]*/, ''), headers)
+        # authentication details
+        req.basic_auth @user, @pass
+        resp = http.request(req)
+        # print out the response for the update
+        puts "DynDNS Update result: #{resp.body}"
+      end
+
+    end
+
+  end
+end

data/lib/rubber/dns/nettica.rb

@@ -0,0 +1,56 @@
+require 'nettica/client'
+module Rubber
+  module Dns
+
+    class Nettica < Base
+
+      def initialize(env)
+        super(env)
+        @nettica_env = @env.dns_providers.nettica
+        @client = ::Nettica::Client.new(@nettica_env.user, @nettica_env.password)
+        @ttl = (@nettica_env.ttl || 300).to_i
+        @record_type = @nettica_env.record_type || "A"
+      end
+
+      def nameserver
+        "dns1.nettica.com"
+      end
+
+      def host_exists?(host)
+        domain_info = @client.list_domain(env.domain)
+        raise "Domain needs to exist in nettica before records can be updated" unless domain_info.record
+        return domain_info.record.any? { |r| r.hostName == host }
+      end
+
+      def create_host_record(host, ip)
+        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
+        @client.add_record(new)
+      end
+
+      def destroy_host_record(host)
+        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == host }
+        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
+        @client.delete_record(old)
+      end
+
+      def update_host_record(host, ip)
+        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == host }
+        update_record(host, ip, old_record)
+      end
+
+      # update the top level domain record which has an empty hostName
+      def update_domain_record(ip)
+        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == '' and r.recordType == 'A' and r.data =~ /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/}
+        update_record('', ip, old_record)
+      end
+
+      def update_record(host, ip, old_record)
+        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
+        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
+        @client.update_record(old, new)
+      end
+
+    end
+
+  end
+end

data/lib/rubber/dns/zerigo.rb

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'httparty'
+
+module Rubber
+  module Dns
+
+
+    class Zone
+      include HTTParty
+      format :xml
+
+      def initialize(customer_id, email, token, domain)
+        self.class.basic_auth email, token
+        self.class.base_uri "https://ns.zerigo.com/accounts/#{customer_id}"
+        @domain = domain
+        refresh()
+      end
+
+      def hosts
+        hosts = self.class.get("/zones/#{@zone['id']}/hosts.xml")
+        return hosts['hosts']
+      end
+
+      def host(hostname)
+        hosts = self.class.get("/zones/#{@zone['id']}/hosts.xml?fqdn=#{hostname}.#{@domain}")
+        return (hosts['hosts'] || []).first
+      end
+
+      def new_host
+        self.class.get("/zones/#{@zone['id']}/hosts/new.xml")['host']
+      end
+
+      def create_host(host)
+        self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
+      end
+
+      def update_host(host)
+        host_id = host['id']
+        self.class.put("/zones/#{@zone['id']}/hosts/#{host_id}.xml", :body => {:host => host})
+      end
+
+      def delete_host(hostname)
+        host_id = host(hostname)['id']
+        self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
+      end
+
+      def refresh
+        zone_id = @zone['id'] rescue nil
+        if zone_id
+          @zone = self.class.get("/zones/#{zone_id}.xml")
+        else
+          zones = self.class.get('/zones.xml')
+          @zone = zones["zones"].find {|z| z["domain"] == @domain }
+        end
+      end
+
+      def data
+        return @zone
+      end
+
+      protected
+
+      def zones()
+        self.class.get('/zones.xml')
+      end
+
+      def zone(domain_name)
+        zone =  zones
+        return zone
+      end
+      
+    end
+    
+    class Zerigo < Base
+
+      def initialize(env)
+        super(env)
+        @zerigo_env = env.dns_providers.zerigo
+        @ttl = (@zerigo_env.ttl || 300).to_i
+        @record_type = @zerigo_env.record_type || "A"
+        @zone = Zone.new(@zerigo_env.customer_id, @zerigo_env.email, @zerigo_env.token, env.domain)
+      end
+
+      def nameserver
+        "a.ns.zerigo.net"
+      end
+
+      def host_exists?(host)
+        @zone.host(host)
+      end
+
+      def create_host_record(host, ip)
+        host = @zone.new_host()
+        host['host-type'] =  @record_type
+        host['ttl'] = @ttl
+        host['hostname'] = host
+        host['data'] = ip
+        @zone.create_host(host)
+      end
+
+      def destroy_host_record(host)
+        @zone.delete_host(host)
+      end
+
+      def update_host_record(host, ip)
+        old = @zone.host(host)
+        old['data'] = ip
+        @zone.update_host(old)
+      end
+
+      # update the top level domain record which has an empty hostName
+      def update_domain_record(ip)
+        old = @zone.hosts.find {|h| h['hostname'].nil? }
+        old['data'] = ip
+        @zone.update_host(old)
+      end
+
+    end
+
+  end
+end