nogara-rubber 1.7.2

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, @nameserver = provider_env.user, provider_env.password, provider_env.nameserver
+        @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 Exception => e
+          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

data/lib/rubber/environment.rb

@@ -0,0 +1,177 @@
+require 'yaml'
+require 'socket'
+require 'delegate'
+
+module Rubber
+  module Configuration
+    # Contains the configuration defined in rubber.yml
+    # Handles selecting of correct config values based on
+    # the host/role passed into bind
+    class Environment
+      attr_reader :config_root
+      attr_reader :config_files
+      attr_reader :config_secret
+
+      def initialize(config_root)
+        @config_root = config_root
+        @config_files = ["#{@config_root}/rubber.yml"]
+        @config_files += Dir["#{@config_root}/rubber-*.yml"].sort
+
+        # add a config file for current env only so that you can override
+        #things for specific envs
+        @config_files -= Dir["#{@config_root}/rubber-*-env.yml"]
+        env_yml = "#{@config_root}/rubber-#{Rubber.env}-env.yml"
+        @config_files << env_yml if File.exist?(env_yml)
+        
+        @items = {}
+        @config_files.each { |file| read_config(file) }
+        @config_secret = bind().rubber_secret
+        read_config(@config_secret) if @config_secret
+      end
+      
+      def read_config(file)
+        Rubber.logger.debug{"Reading rubber configuration from #{file}"}
+        if File.exist?(file)
+          @items = Environment.combine(@items, YAML.load_file(file) || {})
+        end
+      end
+
+      def known_roles
+        roles_dir = File.join(@config_root, "role")
+        roles = Dir.entries(roles_dir)
+        roles.delete_if {|d| d =~ /(^\..*)/}
+        roles += @items['roles'].keys
+        return roles.compact.uniq
+      end
+
+      def current_host
+        Socket::gethostname.gsub(/\..*/, '')
+      end
+      
+      def current_full_host
+        Socket::gethostname
+      end
+      
+      def bind(roles = nil, host = nil)
+        BoundEnv.new(@items, roles, host)
+      end
+
+      # combine old and new into a single value:
+      # non-nil wins if other is nil
+      # arrays just get unioned
+      # hashes also get unioned, but the values of conflicting keys get combined
+      # All else, the new value wins
+      def self.combine(old, new)
+        return old if new.nil?
+        return new if old.nil?
+        value = old
+        if old.is_a?(Hash) && new.is_a?(Hash)
+          value = old.clone
+          new.each do |nk, nv|
+            value[nk] = combine(value[nk], nv)
+          end
+        elsif old.is_a?(Array) && new.is_a?(Array)
+          value = old | new
+        else
+          value = new
+        end
+        return value
+      end
+
+      class HashValueProxy < Hash
+        attr_reader :global
+
+        def initialize(global, receiver)
+          @global = global
+          super()
+          replace(receiver)
+        end
+
+        def rubber_instances
+          @rubber_instances ||= Rubber::Configuration::rubber_instances
+        end
+
+        def [](name)
+          value = super(name)
+          value = global[name] if global && !value
+          return expand(value)
+        end
+
+        def each
+          each_key do |key|
+            yield key, self[key]
+          end
+        end
+
+        def method_missing(method_id)
+          key = method_id.id2name
+          return self[key]
+        end
+
+        def expand_string(val)
+          while val =~ /\#\{[^\}]+\}/
+            val = eval('%Q{' + val + '}', binding)
+          end
+          val = true if val =="true"
+          val = false if val == "false"
+          return val
+        end
+
+        def expand(value)
+          val = case value
+            when Hash
+              HashValueProxy.new(global || self, value)
+            when String
+              expand_string(value)
+            when Enumerable
+              value.collect {|v| expand(v) }
+            else
+              value
+          end
+          return val
+        end
+
+      end
+
+      class BoundEnv < HashValueProxy
+        attr_reader :roles
+        attr_reader :host
+
+        def initialize(global, roles, host)
+          @roles = roles
+          @host = host
+          bound_global = bind_config(global)
+          super(nil, bound_global)
+        end
+
+        def full_host
+          @full_host ||= "#{host}.#{domain}" rescue nil
+        end
+
+        # Forces role/host overrides into config
+        def bind_config(global)
+          global = global.clone()
+          role_overrides = global.delete("roles") || {}
+          host_overrides = global.delete("hosts") || {}
+          Array(roles).each do |role|
+            Array(role_overrides[role]).each do |k, v|
+              global[k] = Environment.combine(global[k], v)
+            end
+          end
+          Array(host_overrides[host]).each do |k, v|
+            global[k] = Environment.combine(global[k], v)
+          end
+          return global
+        end
+        
+        def method_missing(method_id)
+          key = method_id.id2name
+          return self[key]
+        end
+
+      end
+
+    end
+
+  end
+end