nirvdrum-rubber 1.1.7

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,78 @@
+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 =>host, :data => r.address}]
+          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(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(opts, [:host, :domain])
+        new_opts = setup_opts(opts, [:data])
+        
+        host = hostname(old_opts[:host])
+        ip = new_opts[:data]
+        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,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,174 @@
+require 'rubygems'
+require 'httparty'
+
+module Rubber
+  module Dns
+
+
+    class Zone
+      include HTTParty
+      format :xml
+
+      @@zones = {}
+      def self.get_zone(domain, provider_env)
+       @@zones[domain] ||= Zone.new(provider_env.customer_id, provider_env.email, provider_env.token, domain)
+      end
+
+      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 check_status(response)
+        code = response.code
+        if code < 200 || code > 299
+          msg = "Failed to access zerigo api (http_status=#{code})"
+          msg += ", check dns_providers.zerigo.customer_id/email/token in rubber.yml" if code == 401
+          raise msg
+        end
+        return response
+      end
+
+      def create_host(opts)
+        host = opts_to_host(opts, new_host())
+        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
+      end
+
+      def find_host_records(opts={})
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+        has_host = hn && hn != '*'
+
+        url = "/zones/#{@zone['id']}/hosts.xml"
+        if has_host
+          url << "?fqdn="
+          url << "#{hn}." if hn.strip.size > 0
+          url << "#{@domain}"
+        end
+        hosts = self.class.get(url)
+
+        # returns 404 on not found, so don't check status
+        hosts = check_status hosts unless has_host
+
+        hosts['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 << host_to_opts(h) if keep
+        end if hosts['hosts']
+
+        return result
+      end
+
+      def update_host(host_id, opts)
+        host = opts_to_host(opts, new_host())
+        check_status self.class.put("/zones/#{@zone['id']}/hosts/#{host_id}.xml", :body => {:host => host})
+      end
+
+      def delete_host(host_id)
+        check_status self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
+      end
+
+      def refresh
+        zone_id = @zone['id'] rescue nil
+        if zone_id
+          @zone = check_status self.class.get("/zones/#{zone_id}.xml")
+        else
+          zones = check_status self.class.get('/zones.xml')
+          @zone = zones["zones"].find {|z| z["domain"] == @domain }
+        end
+        if ! @zone
+          zone = new_zone()
+          zone['domain'] = @domain
+          zones = check_status self.class.post('/zones.xml', :body => {:zone => zone})
+          @zone = zones['zone']
+        end
+      end
+
+      def zone_record
+        return @zone
+      end
+
+      private
+
+      def new_host
+        check_status(self.class.get("/zones/#{@zone['id']}/hosts/new.xml"))['host']
+      end
+
+      def new_zone
+        check_status(self.class.get("/zones/new.xml"))['zone']
+      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 host_to_opts(host)
+        opts = {}
+        opts[:id] = host['id'] 
+        opts[:domain] = @domain
+        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
+    end
+    
+    class Zerigo < Base
+
+      def initialize(env)
+        super(env, "zerigo")
+      end
+
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
+
+        zone.find_host_records(opts)
+      end
+
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        zone = Zone.get_zone(opts[:domain], provider_env)
+
+        zone.create_host(opts)
+      end
+
+      def destroy_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
+
+        find_host_records(opts).each do |h|
+          zone.delete_host(h[:id])
+        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), [])
+        zone = Zone.get_zone(old_opts[:domain], provider_env)
+
+        find_host_records(old_opts).each do |h|
+          zone.update_host(h[:id], h.merge(new_opts))
+        end
+      end
+
+    end
+
+  end
+end