sml-rubber 0.9.1

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/cloud/#{provider}"
+      clazz = Rubber::Dns.const_get(provider.capitalize)
+      return clazz.new(env)
+    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

data/lib/rubber/environment.rb

@@ -0,0 +1,161 @@
+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"] + Dir["#{@config_root}/rubber-*.yml"].sort
+        @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)
+        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 =~ /(^\..*)/}
+      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 [](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
+        attr_reader :full_host
+
+        def initialize(global, roles, host)
+          @roles = roles
+          @host = host
+          bound_global = bind_config(global)
+          super(nil, bound_global)
+          @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") || {}
+          roles.to_a.each do |role|
+            role_overrides[role].each do |k, v|
+              global[k] = Environment.combine(global[k], v)
+            end if role_overrides[role]
+          end
+          host_overrides[host].each do |k, v|
+            global[k] = Environment.combine(global[k], v)
+          end if host_overrides[host]
+          return global
+        end
+        
+        def method_missing(method_id)
+          key = method_id.id2name
+          return self[key]
+        end
+
+      end
+
+    end
+
+  end
+end