rubber-jcarnegie 0.0.1

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/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.rb

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

data/lib/rubber/dns/base.rb

@@ -0,0 +1,84 @@
+module Rubber
+  module Dns
+
+    class Base
+
+      attr_reader :env, :provider_env, :provider_name
+
+      def initialize(env, provider_name)
+        @env = env
+        @provider_name = provider_name
+        @provider_env = @env.dns_providers[provider_name]
+      end
+
+      def update(host, ip)
+        if up_to_date(host, ip)
+          puts "IP has not changed for #{host}, not updating dynamic DNS"
+        else
+          if find_host_records(:host => host).size == 0
+            puts "Creating dynamic DNS: #{host} => #{ip}"
+            create_host_record(:host => host, :data => ip)
+          else
+            puts "Updating dynamic DNS: #{host} => #{ip}"
+            update_host_record({:host => host}, {:host => host, :data => ip})
+          end
+        end
+      end
+
+      def destroy(host)
+        if find_host_records(:host => host).size != 0
+          puts "Destroying dynamic DNS record: #{host}"
+          destroy_host_record(:host => host)
+        end
+      end
+
+      def up_to_date(host, ip)
+        find_host_records(:host => host).any? {|host| host[:data] == ip}
+      end
+
+      def create_host_record(opts = {})
+        raise "create_host_record not implemented"
+      end
+
+      def find_host_records(opts = {})
+        raise "find_host_records not implemented"
+      end
+
+      def update_host_record(old_opts={}, new_opts={})
+        raise "update_host_record not implemented"
+      end
+
+      def destroy_host_record(opts = {})
+        raise "destroy_host_record not implemented"
+      end
+
+      def host_records_equal?(lhs_opts = {}, rhs_opts = {})
+        lhs = setup_opts(lhs_opts)
+        rhs = setup_opts(rhs_opts)
+        [lhs, rhs].each {|h| h.delete(:id); h.delete(:priority) if h[:priority] == 0}
+        lhs == rhs
+      end
+
+      def setup_opts(opts, required=[])
+        default_opts = {:domain => @env.domain,
+                        :type => @provider_env['type'] || @provider_env.record_type || 'A',
+                        :ttl => @provider_env.ttl || 300}
+        
+        if opts.delete(:no_defaults)
+          actual_opts = Rubber::Util::symbolize_keys(opts)
+        else
+          actual_opts = default_opts.merge(Rubber::Util::symbolize_keys(opts))
+        end
+
+        required.each do |r|
+          raise "Missing required options: #{r}" unless actual_opts[r]
+        end
+
+        return actual_opts
+      end
+      
+
+    end
+
+  end
+end

data/lib/rubber/dns/dyndns.rb

@@ -0,0 +1,77 @@
+module Rubber
+  module Dns
+
+    class Dyndns < Base
+
+      def initialize(env)
+        super(env, 'dyndns')
+        @user, @pass = provider_env.user, provider_env.password
+        @update_url = provider_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 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("#{host}.#{provider_env.domain}").to_s rescue nil
+        end
+        return ip == current_ip
+      end
+      
+      def find_host_records(opts={})
+        opts = setup_opts(opts, [:host, :domain])
+        hostname = "#{opts[:host]}.#{opts[:domain]}"
+        begin
+          Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
+            r = dns.getresource(hostname, Resolv::DNS::Resource::IN::A)
+            result = [{:host =>opts[:host], :data => r.address}]
+          end
+        rescue
+          puts "Rescue #{e} #{e.message}"
+          raise "Domain needs to exist in dyndns as an A record before record can be updated"
+        end
+      end
+
+      def create_host_record(opts={})
+        puts "WARNING: No create record available for dyndns, you need to do so manually"
+      end
+
+      def destroy_host_record(opts={})
+        puts "WARNING: No destroy record available for dyndns, you need to do so manually"
+      end
+
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+
+        host = "#{old_opts[:host]}.#{old_opts[:domain]}"
+        ip = new_opts[:data]
+        update_url = eval('%Q{' + @update_url + '}')
+        # puts 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,117 @@
+require 'nettica/client'
+module Rubber
+  module Dns
+
+    class Nettica < Base
+
+      def initialize(env)
+        super(env, "nettica")
+        @client = ::Nettica::Client.new(provider_env.user, provider_env.password)
+      end
+
+      def check_status(response)
+        code = case
+          when response.respond_to?(:status)
+            response.status
+          when response.respond_to?(:result)
+            response.result.status
+          else
+            500
+        end
+        if code < 200 || code > 299
+          msg = "Failed to access nettica api (http_status=#{code})"
+          msg += ", check dns_providers.nettica.user/password in rubber.yml" if code == 401
+          raise msg
+        end
+        return response
+      end
+
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+
+        domain_info = find_or_create_zone(opts[:domain])
+
+        domain_info.record.each do |h|
+          keep = true
+          if hn && h.hostName != hn && hn != '*'
+            keep = false
+          end
+          if ht && h.recordType != ht && ht != '*'
+            keep = false
+          end
+          if hd && h.data != hd
+            keep = false
+          end
+          result << record_to_opts(h) if keep
+        end
+
+        return result
+      end
+
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        find_or_create_zone(opts[:domain])
+        record = opts_to_record(opts)
+        check_status @client.add_record(record)
+      end
+
+      def destroy_host_record(opts = {})
+        find_host_records(opts).each do |h|
+          record = opts_to_record(h)
+          check_status @client.delete_record(record)
+        end
+      end
+
+      def update_host_record(old_opts = {}, new_opts = {})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts.merge(:no_defaults =>true), [])
+        find_host_records(old_opts).each do |h|
+          old_record = opts_to_record(h)
+          new_record = opts_to_record(h.merge(new_opts))
+          check_status @client.update_record(old_record, new_record)
+        end
+      end
+
+      private
+
+      def find_or_create_zone(domain)
+        domain_info = @client.list_domain(domain)
+        if domain_info.record
+          check_status domain_info
+        else
+          check_status @client.create_zone(domain)
+          domain_info = check_status @client.list_domain(domain)
+          raise "Could not create zone in nettica: #{domain}" unless domain_info.record
+        end
+        return domain_info
+      end
+
+      def opts_to_record(opts)
+        record = @client.create_domain_record(opts[:domain],
+                                              opts[:host],
+                                              opts[:type],
+                                              opts[:data],
+                                              opts[:ttl],
+                                              opts[:priority] || 0)
+        return record
+      end
+
+      def record_to_opts(record)
+        opts = {}
+        opts[:host] = record.hostName || ''
+        opts[:domain] = record.domainName
+        opts[:type] = record.recordType
+        opts[:data] = record.data if record.data
+        opts[:ttl] = record.tTL if record.tTL
+        opts[:priority] = record.priority if record.priority
+        return opts
+      end
+    end
+
+  end
+end

data/lib/rubber/dns/zerigo.rb

@@ -0,0 +1,115 @@
+require 'rubygems'
+
+begin
+  require 'zerigo_dns'
+rescue LoadError
+  puts "Missing the zerigo_dns gem.  Install with `sudo gem install zerigo_dns`."
+  exit(-1)
+end
+
+module Rubber
+  module Dns
+
+    class Zerigo < Base
+
+      def initialize(env)
+        super(env, "zerigo")
+
+        ::Zerigo::DNS::Base.user = provider_env.email
+        ::Zerigo::DNS::Base.password = provider_env.token
+      end
+
+      def host_to_opts(host)
+        opts = {}
+        opts[:id] = host.id
+        opts[:host] = host.hostname || ''
+        opts[:type] = host.host_type
+        opts[:data] = host.data if host.data
+        opts[:ttl] = host.ttl if host.ttl
+        opts[:priority] = host.priority if host.priority
+        return opts
+      end
+
+      def opts_to_host(opts, host={})
+        host['hostname'] = opts[:host]
+        host['host_type'] =  opts[:type]
+        host['data'] = opts[:data] if opts[:data]
+        host['ttl'] = opts[:ttl] if opts[:ttl]
+        host['priority'] = opts[:priority] if opts[:priority]
+        return host
+      end
+
+      def find_hosts(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        result = []
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        params = { :zone_id => zone.id }
+
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+        has_host = hn && hn != '*'
+        if has_host
+          url = ""
+          url << "#{hn}." if hn.strip.size > 0
+          url << "#{opts[:domain]}"
+          params[:fqdn] = url
+        end
+
+        begin
+          hosts = ::Zerigo::DNS::Host.find(:all, :params=> params)
+
+          hosts.each do |h|
+            keep = true
+            if ht && h.host_type != ht && ht != '*'
+              keep = false
+            end
+            if hd && h.data != hd
+              keep = false
+            end
+            result << h if keep
+          end if hosts
+        rescue ActiveResource::ResourceNotFound => e
+        end
+
+        return result
+      end
+
+      def find_host_records(opts = {})
+        hosts = find_hosts(opts)
+        result = hosts.collect {|h| host_to_opts(h).merge(:domain => opts[:domain]) }
+        return result
+      end
+
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        ::Zerigo::DNS::Host.create(opts_to_host(opts).merge(:zone_id => zone.id))
+      end
+
+      def destroy_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+
+        find_hosts(opts).each do |h|
+          h.destroy || raise("Failed to destroy #{h.hostname}")
+        end
+      end
+
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts, [:host, :domain, :type, :data])
+        zone = ::Zerigo::DNS::Zone.find_or_create(old_opts[:domain])
+
+        find_hosts(old_opts).each do |h|
+          opts_to_host(new_opts).each do |k, v|
+            h.send("#{k}=", v)
+          end
+          h.save || raise("Failed to update host #{h.hostname}, #{h.errors.full_messages.join(', ')}")
+        end
+      end
+
+    end
+
+  end
+end