dnsomatic 0.1.1

data/bin/dnsomatic

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby
+
+begin
+  require 'dnsomatic'
+rescue LoadError => e
+  # a small hack in the case where we aren't a gem
+  $: << File.join(File.dirname($0), '..', 'lib')
+  retry
+end
+
+begin
+  $opts = DNSOMatic::Opts.instance
+  $opts.parse(ARGV)
+
+  c = DNSOMatic::Config.new($opts.cf)
+
+  if $opts.showcf
+    $stdout.puts "This is your configuration after merging in the defaults."
+    $stdout.puts "It has been pruned to only display the stanza named: #{$opts.name}" if $opts.name
+    $stdout.puts c.merged_config($opts.name)
+    exit
+  end
+
+  if $opts.stanza and $opts.verbose
+    $stdout.puts "Will only update #{$opts.name}."
+  end
+
+  updaters = c.updaters($opts.name)
+
+  updaters.each_pair do |name, obj|
+    $stdout.puts "Working with host update definition: #{name}" if $opts.verbose
+    if $opts.print
+      puts obj
+    else
+      obj.send( $opts.force ? 'update!' : 'update')
+    end
+  end
+rescue DNSOMatic::Error => e
+  $stderr.puts e
+  if $opts.debug
+    $stderr.puts "Backtrace:"
+    $stderr.puts e.backtrace
+  end
+rescue => e
+  $stderr.puts "Rescued an unhandled exception of type: #{e.class}"
+  $stderr.puts "The exception contains the following message:"
+  $stderr.puts e.message
+  if $opts.debug
+    $stderr.puts "Backtrace:"
+    $stderr.puts e.backtrace
+  end
+  exit 1
+end

data/lib/dnsomatic.rb

@@ -0,0 +1,162 @@
+require 'yaml'
+require 'open-uri'
+
+# :title: dnsomatic - a DNS-o-Matic update client
+#
+# = dnsomatic - a DNS-o-Matic update client
+#
+# Author:: Ben Walton (mailto: bdwalton@gmail.com)
+# Copyright:: Copyright (c) 2008 Ben Walton
+# License:: GNU General Public License (GPL) version 3
+#
+# = Summary
+#
+# By default, dnsomatic tries to avoid polling or updating its address too
+# often.  It will not check a remote IP lookup url more often than every half
+# hour.  It will avoid updating DNS-o-Matic for up to 15 days if the IP
+# detected hasn't changed.
+#
+# = Configuration
+#
+# Configuration is specified by a small YAML file with a default location
+# of $HOME/.dnsomatic.cf
+#
+# A basic configuration can be as simple as:
+#   defaults:
+#     username: YOUR_DNSOMATIC_USERNAME
+#     password: YOUR_DNSOMATIC_PASSWORD
+#
+# The dnsomatic client may update all of your registered DNS-o-Matic names
+# in one shot or individual names one at a time.  The defaults: stanza in the
+# configuration provides default values for any hostname update stanzas to
+# follow, although no extra stanzas are required.
+#
+# To provide alternate stanzas, add items in your config like:
+#   myhost:
+#     hostname: myhost.dyndns.foo
+#     mx: mx.example.net
+#
+# When that stanza is used in conjunction with the above defaults stanza, you
+# have a fully operation host update definition (myhost: would inherit the
+# username and password from defaults:)
+#
+# In some cases it may be desirable to fetch the Web visible IP for a system
+# from a different URL than the dnsomatic option (http://myip.dnsomatic.com).
+# To allow for this, you may add a webipfetchurl: paramter to a confiruation
+# stanza (or defaults:).  Consider:
+#   otherhost:
+#     hostname: otherhost.dyndns.foo
+#     webipfetchurl: http://ipfetch.example.net/
+#
+# If all three of the above stanzas were in the same configuration file, you
+# would send two update requests (conditional upon changed IP addresses and/or
+# expiration times), with the second polling for its IP at the
+# ipfetch.example.net url instead of the default myip.dnsomatic.com service.
+#
+# When there are update stanzas named specifically (in addition to defaults:),
+# defaults is used only to provide default values for the other stanzas.  For
+# most users wanting to define more than one updater stanza, you would provide
+# the username and password via the defaults: stanza and then a hostname value
+# for the individual stanza definitions.  Once the defaults are merged into the
+# specific stanzas, they are ignored.  To see how the merging works, you may
+# use the 'display' option (see options with --help), which will dump to stdout
+# a YAML serialized view of the merged configuration.
+#
+# This allows you to obtain an IP from multiple (or just alternate services).
+# Although this might sound less than useful, it would be handy if you wanted
+# different IP's associated with machines that could route to the internet via
+# two different public IP's, or if you wanted to poll an internal service and
+# update a public name with an internal IP.
+#
+# A complete list of options that may be specified in the defaults: or a named
+# update definition are:
+# * username - your dnsomatic username
+# * password - your dnsomatic password
+# * mx - a hostname that will handle mail delivery for this host.  it must
+#   resolve to an IP or DNS-o-Matic will ignore it.
+# * backmx - a lower priority mx record.  sames rules as mx.  you may also list
+#		these as NOCHG, which tells DNS-o-Matic to leave them as is.
+# * hostname - the hostname to update.  the defaults specify this as
+#		all.dnsomatic.com, which tells dnsomatic to update all listed
+#		records with the same values.
+# * wildcard - indicates whether foo.hostname and bar.hostname and baz.hostname should also resolve to the same IP as hostname.
+#		- ON = enable
+#		- NOCHG = leave it as is
+#		- _other_ = disable
+# * offline - sets the hostname of offline mode, which may do some redirection
+#		things depending on the service being updated.
+#		- YES = enable
+#		- NOCHG = leave it as is
+#		- _other_ = disable
+#
+# = Usage
+#
+# Usage: dnsomatic [options]
+#   -m, --minimum SEC                The minimum time between updates (def: 30m)
+#   -M, --maximum SEC                The maximum time between updates (def: 15d)
+#   -a, --alert                      Emit an alert if the IP is updated
+#   -n, --name NAME                  Only update host stanza NAME
+#   -d, --display-config             Display the configuration and exit
+#   -c, --config FILE                Use an alternate config file
+#   -f, --force                      Force an update, even if IP is unchanged
+#   -p, --print                      Output the update URLs.  No action taken
+#   -v, --verbose                    Display runtime messages
+#   -V, --version                    Display version and exit
+#   -x, --debug                      Output additional info in error situations
+#   -h, --help                       Display this help text
+
+module DNSOMatic
+  VERSION = '0.1.1'
+  USERAGENT = "Ruby_DNS-o-Matic/#{VERSION}"
+
+  # We provide our easily distinguishable exception class so that we can easily
+  # differntiate our errors from others.
+  class Error < Exception; end
+
+  def self.http_fetch (url)
+    uri = URI.parse(url)
+
+    begin
+      res = if uri.user and uri.password
+	      open(url, 'User-Agent' => USERAGENT,
+		:http_basic_authentication => [uri.user, uri.password])
+	    else
+	      open(url, 'User-Agent' => USERAGENT)
+	    end
+      res.read
+    rescue OpenURI::HTTPError, SocketError => e
+      msg = "Error communicating with #{uri.host}\n"
+      msg += "Message was: #{e.message}\n"
+      msg += "Full URL being requested: #{uri}"
+      raise(DNSOMatic::Error, msg)
+    end
+  end
+
+  def self.yaml_read(file)
+    begin
+      yaml = YAML::load(File.open(file))
+    rescue Exception => e
+      msg = "An exception (#{e.class}) occurred while reading a yaml file: #{file}\n"
+      msg += "The error message is: #{e.message}"
+      raise(DNSOMatic::Error, msg)
+    end
+  end
+
+  def self.yaml_write(file, data)
+    begin
+      File.open(file, 'w') do |f|
+	f.puts data.to_yaml
+      end
+    rescue Exception => e
+      msg = "An exception (#{e.class}) occurred while writing a yaml file: #{file}\n"
+      msg += "The error message is: #{e.message}"
+      raise(DNSOMatic::Error, msg)
+    end
+  end
+end
+
+require 'dnsomatic/opts'
+require 'dnsomatic/config'
+require 'dnsomatic/updater'
+require 'dnsomatic/iplookup'
+require 'dnsomatic/logger'

data/lib/dnsomatic/config.rb

@@ -0,0 +1,142 @@
+require 'net/https'
+
+module DNSOMatic
+  # A class to handle 'parsing' the configuration files and setting defaults
+  # as required.  Config files are actually YAML files, so the parsing is
+  # offloaded for the most part.
+  class Config
+    #in most cases, a user can simply set username and password in a defaults:
+    #stanza and fire the client.
+    @@defaults = { 'hostname' => 'all.dnsomatic.com',
+		   'wildcard' => 'NOCHG',
+		   'mx' => 'NOCHG',
+		   'backmx' => 'NOCHG',
+		   'offline' => 'NOCHG',
+		   'webipfetchurl' => 'http://myip.dnsomatic.com/' }
+
+    # Create a new instance with the option of specifying an alternate config
+    # file to read.  The default config file is either $HOME/.dnsomatic.cf (on
+    # unix or if Windows specifies a $HOME environment variable) or
+    # %APPDATA%/.dnsomatic.cf for most Windows environments.
+    def initialize(conffile = nil)
+      stdcf = File.join(ENV['HOME'] || ENV['APPDATA'], '.dnsomatic.cf')
+      if conffile
+	if File.exists?(conffile)
+	  @cf = conffile
+	else
+	  raise(DNSOMatic::ConfErr, "Invalid config file: #{conffile}")
+	end
+      elsif File.exists?(stdcf)
+	@cf = stdcf
+      else
+	#in this case, the values from the defaults: stanza in the default conf
+	#will provide all values required.
+	@cf = nil
+      end
+
+      @updaters = nil
+      @config = {}
+
+      # the user config must supply values for these, either in a specific
+      # host updater stanza or by overriding the global default in defaults:
+      @req_conf = %w(username password)
+
+      msg = @cf.nil? ?  "Couldn't find a user config.  Using defaults only." : \
+	  "Using config file #{@cf}"
+      Logger::log(msg)
+
+      load()
+    end
+
+    # Provide a view of the configuration file after merging defaults.  This
+    # is returned as a YAML string, suitable for redirecting right into a
+    # config file.  Optionally, the return value can be 'pruned' to show only
+    # one host update stanza by passing in the desired name as a string.
+    def merged_config(prune_to = nil)
+      prune_to.nil? ? @config.to_yaml : one_key(@config, prune_to).to_yaml
+    end
+
+    # Return a list of Updater objects.  Each host update stanza is turned into
+    # an individual object.  This may be pruned to a single Updater by passing
+    # in the name of the stanza title.
+    def updaters(prune_to = nil)
+      #don't create updater objects until they're actually requested.
+      #(saves a little overhead if just displaying the config)
+		      
+      if @updaters.nil?
+	@updaters = {}
+	@config.each_key do |token|
+	  @updaters[token] = Updater.new(@config[token])
+	end
+      end
+
+      prune_to.nil? ? @updaters : one_key(@updaters, prune_to)
+    end
+
+    private
+
+    def one_key(hsh, key)
+      if ! hsh.has_key?(key)
+	msg = "Invalid host stanza filter ('#{key}').\n"
+	msg += "You config doesn't define anything with that name."
+	raise(DNSOMatic::ConfErr, msg)
+      else
+	{ key => hsh[key] }
+      end
+    end
+
+    def load
+      return @@defaults if @cf.nil?
+
+      conf = DNSOMatic::yaml_read(@cf)
+      raise DNSOMatic::ConfErr, "Invalid configuration format in #{@cf}" unless conf.kind_of?(Hash)
+
+      if conf.has_key?('defaults')
+	#allow the user to override our built-in defaults
+	@@defaults.merge!(conf['defaults'])
+	#if they've provided only the defaults stanza, we'll use it to perform
+	#the update, otherwise remove it as it has been folded into @@defaults
+	conf.delete('defaults') if conf.keys.size > 1
+      end
+
+      conf.each_key do |token|
+	stanza = @@defaults.merge(conf[token])
+	@req_conf.each do |required|
+	  #still test for existence in case the defaults get munged.
+	  if !stanza.has_key?(required) or stanza[required].nil?
+	    msg = "Invalid configuration for Host Updater named '#{token}'\n"
+	    msg += "Please define the field: #{required}."
+	    raise DNSOMatic::ConfErr, msg
+	  end
+	end
+
+	#just in case
+	stanza.each_pair do |k,v|
+	  stanza[k] = fmt(v)
+	end
+
+	#save our merged version in case we're just dump our config to stdout
+	@config[token] = stanza
+      end
+    end
+
+    def fmt(val)
+      #because YAML interprets a raw YES or NO as a boolean true/false and we
+      #don't want to burden user with prefixing the value with !str, we'll
+      #attempt to deduce what they meant here...
+      if [TrueClass, FalseClass].include?(val.class)
+	val ? 'ON' : 'OFF'
+      elsif val.kind_of?(NilClass)
+	'NOCHG'
+      elsif val.kind_of?(String)
+	case val.downcase
+	  when 'no': 'OFF'
+	  when 'yes': 'ON'
+	  else val.gsub(/\s+/, '')
+	end
+      else
+	val.to_s.gsub(/\s+/, '')
+      end
+    end
+  end
+end

data/lib/dnsomatic/iplookup.rb

@@ -0,0 +1,142 @@
+require 'singleton'
+require 'date'
+
+module DNSOMatic
+  # This class handles actually fetching the remotely (not necessarily internet)
+  # visible IP for a provided URL.  It manages both a minimum delay between
+  # checks (default 30m) and a maximum time before it reports a CHANGED status
+  # regardless of the result from the remote ip lookup url.
+  class IPStatus
+    CHANGED = true
+    UNCHANGED = false
+
+    attr_reader :ip
+
+    # A URL must be provided that returns the IP of the system that requests
+    # the URL.  A commonly used example is http://www.whatismyip.org
+    def initialize(url)
+      @url = url
+      @status = CHANGED	#all new lookups are changed.
+      @ip = getip()
+      @last_update = Time.now
+      Logger::log("Fetched new IP #{@ip} from #{@url}.")
+    end
+
+    # Tell a client whether or not we have a different IP than the last time
+    # we were asked.  This may be faked in the case where we've reached the
+    # the maximum time we allow before forcing an update.
+    def changed?
+      @status
+    end
+
+    # Calling this method requests that we retrieve our IP from the remote URL
+    # and potentially alter our status as returned by changed?.
+    def update
+      if min_elapsed?
+	Logger::log("Returned cached IP #{@ip} from #{@url}.")
+	@status = UNCHANGED
+      else
+	ip = getip()
+	@last_update = @status ? Time.now : @last_update
+
+	if !@ip.eql?(ip)
+	  Logger::log("Detected IP change (#{@ip} -> #{ip}) from #{@url}.")
+	else
+	  Logger::log("No IP change detected from #{@url}.")
+	end
+
+	@status = (max_elapsed? or !@ip.eql?(ip)) ? CHANGED : UNCHANGED
+	@ip = ip
+      end
+    end
+
+    private
+    def min_elapsed?
+      if Time.now - @last_update <= $opts.minimum
+	Logger::log("Minimum lookup interval not expired.")
+	true
+      else
+	false
+      end
+    end
+
+    def max_elapsed?
+      if Time.now - @last_update >= $opts.maximum
+	Logger::log("Maximum interval between updates has elapsed.  Update will be forced.")
+	true
+      else
+	false
+      end
+    end
+
+    def getip
+      ip = DNSOMatic::http_fetch(@url)
+      if !ip.match(/(\d{1,3}\.){3}\d{1,3}/)
+	msg = "Strange return value from IP Lookup service: #{@url}\n"
+	msg += "Body of HTTP response was:\n"
+	msg += ip
+	raise(DNSOMatic::Error, msg)
+      else
+	ip
+      end
+    end
+  end
+
+  # Any callers wishing to use IPStatus objects should request them via an
+  # instance of IPLookup.  IPLookup is a singleton object that will cache
+  # IPStatus objects across sessions by persisting them to a YAML file.
+  class IPLookup
+    include Singleton
+
+    # Allow a caller to toggle the cache on and off.
+    attr_accessor :persist
+
+    # Because we're a singleton, we don't take any initialization arguments.
+    def initialize
+      fn = 'dnsomatic-' + Process.uid.to_s + '.cache'
+      @cache_file = File.join(ENV['TEMP'] || '/tmp', fn)
+
+      @cache = Hash.new
+      @persist = true
+    end
+
+    # This allows callers to alter which file we will persist our cache of
+    # IPStatus objects to.
+    def setcachefile(file)
+      if !File.writable?(File.dirname(file))
+	raise(DNSOMatic::Error, "Unwritable cache file directory.")
+      elsif File.exists?(file) and !File.writable(file)
+	raise(DNSOMatic::Error, "Unwritable cache file")
+      end
+      @cache_file = file
+    end
+
+    # This is the method a caller would use to request and IPStatus object.
+    # The url is passed to new() when the object is created or returned from
+    # the cache.
+    def ip_from_url(url)
+      load()
+      #implement a simple cache to prevent making multiple http requests
+      #to the same remote agent (in the case where a user defines multiple
+      #updater stanzas that use the same ip fetch url).
+      #because an access for a key that doesn't exist returns and inserts
+      #a new IPStatus object, we don't differntiate between seen and unseen
+      #here.
+      (@cache[url] ||= IPStatus.new(url)).update
+
+      save()  #ensure that we get spooled to disk.
+      @cache[url]
+    end
+
+    private
+    def load
+      if File.exists?(@cache_file) and @persist
+	@cache = DNSOMatic::yaml_read(@cache_file)
+      end
+    end
+
+    def save
+      DNSOMatic::yaml_write(@cache_file, @cache) if @persist 
+    end
+  end
+end

data/lib/dnsomatic/logger.rb

@@ -0,0 +1,21 @@
+module DNSOMatic
+  # A simple class to provide consistent logging throughout the various other
+  # classes.  All methods are class methods, so no instance is required.
+  class Logger
+    # Output a message to stdout if the user specified the verbose command
+    # line option.
+    def self.log(msg)
+      $stdout.puts msg if $opts.verbose
+    end
+
+    # Output a message to stderr regardless of verbose command line option.
+    def self.warn(msg)
+      $stderr.puts msg
+    end
+  
+    # Output a message to stdout if either verbose or alert was specified.
+    def self.alert(msg)
+      $stdout.puts msg if $opts.verbose or $opts.alert
+    end
+  end
+end

data/lib/dnsomatic/opts.rb

@@ -0,0 +1,112 @@
+require 'optparse'
+require 'ostruct'
+require 'singleton'
+
+module DNSOMatic
+  # A class to handle option parsing for the dnsomatic client.
+  # It acts as a singleton and will recreate its internal representation
+  # of the options each time parse(ARGS) is called.
+  class Opts
+    @@opts = OpenStruct.new
+
+    include Singleton
+
+    # No arguments, but sets the internal options to the defaults.
+    def initialize
+      setdefaults()
+    end
+
+    # Parse and array of arguments and set the interal options.  Typically
+    # ARGV is passed, but that is not required.  Any array of strings that
+    # look like arguments will work (makes testing easier).
+    def parse(args)
+      setdefaults()
+      begin
+	opts = OptionParser.new do |o|
+	  o.on('-m', '--minimum SEC', 'The minimum time between updates (def: 30m)') do |i|
+	    @@opts.minimum = i.to_i
+	  end
+
+	  o.on('-M', '--maximum SEC', 'The maximum time between updates (def: 15d)') do |i|
+	    @@opts.maximum = i.to_i
+	  end
+#
+	  #making this an option (off by default) means we can operate
+	  #completely silently by default.
+	  o.on('-a', '--alert', 'Emit an alert if the IP is updated') do |a|
+	    @@opts.alert = true
+	  end
+
+	  o.on('-n', '--name NAME', 'Only update host stanza NAME') do |n|
+	    @@opts.name = n
+	  end
+
+	  o.on('-d', '--display-config', 'Display the configuration and exit') do 
+	    @@opts.showcf = true
+	  end
+
+	  o.on('-c', '--config FILE', 'Use an alternate config file') do |f|
+	    @@opts.cf = f
+	  end
+
+	  o.on('-f', '--force', 'Force an update, even if IP is unchanged') do
+	    @@opts.force = true
+	  end
+
+	  o.on('-p', '--print', 'Output the update URLs.  No action taken') do
+	    @@opts.print = true
+	  end
+
+	  o.on('-v', '--verbose', 'Display runtime messages') do
+	    @@opts.verbose = true
+	  end
+
+	  o.on('-V', '--version', 'Display version and exit') do
+	    $stdout.puts DNSOMatic::VERSION
+	    exit 0
+	  end
+
+	  o.on('-x', '--debug', 'Output additional info in error situations') do
+	    @@opts.debug = true
+	  end
+
+	  o.on('-h', '--help', 'Display this help text') { puts o; exit; }
+	end
+	opts.parse!(args)
+
+	if args.size > 0
+	  raise(DNSOMatic::Error, "Extra arguments given: #{args.join(', ')}")
+	end
+
+      rescue OptionParser::ParseError => e
+	msg = "Extra/Unknown arguments used:\n"
+	msg += "\t#{e.message}\n"
+	msg += "Remaining args: #{args.join(', ')}" if args.size > 0
+	raise(DNSOMatic::Error, msg)
+      end
+    end
+
+    # This is a simple wrapper that passes method calls to our internal option
+    # store (an openstruct) so that a client can call opts.alert and get the
+    # value from the @@opts.alert variable.
+    def method_missing(meth, *args)
+      @@opts.send(meth)
+    end
+
+    private
+    # A quick way to set all of our preferred defaults
+    def setdefaults
+      @@opts.name = nil
+      @@opts.cf = nil
+      @@opts.showcf = false
+      @@opts.force = false
+      @@opts.print = false
+      @@opts.verbose = false
+      @@opts.minimum = 1800 #30 minutes
+      @@opts.maximum = 1296000	#15 days
+      @@opts.debug = false
+      @@opts.alert = false
+    end
+
+  end
+end

data/lib/dnsomatic/updater.rb

@@ -0,0 +1,79 @@
+
+module DNSOMatic
+  # This is the primary interface used to perform updates of IP information
+  # to the DNS-o-Matic service.
+  class Updater
+    # Initialize and updater object with a set of config options.  config is
+    # a hash that must contain the following keys:
+    # * hostname: a string representing the hostname to be updated
+    # * mx: a string representing a valid MX for hostname
+    # * backmx: a string representing a secondary MX for hostname
+    # * username: the username with rights to update hostname
+    # * password: the corresponding password
+    # * webipfetchurl: a url that returns the IP of the system requesting the it
+    # * offline: determines whether 'offline' mode should be used.
+    def initialize(config)
+      @config = config
+      #use a cache in case other host stanzas have already looked up
+      #our ip using the same remote agent.
+      @lookup = DNSOMatic::IPLookup.instance
+    end
+
+    # Build and send the url that is passed to the DNS-o-Matic system to
+    # request an update for the hostname provided in the configuration.
+    # By default, the we'll honour the changed? status of the IPStatus object
+    # returned to us, but if force is set to true, we'll send the update
+    # request anyway.
+    def update(force = false) url = upd_url()
+
+      if !@ipstatus.changed? and !force
+	Logger::log("No change in IP detected for #{@config['hostname']}.  Not updating.")
+      else
+	Logger::alert("Updating IP for #{@config['hostname']} to #{@ipstatus.ip}.")
+	update = DNSOMatic::http_fetch(url)
+
+	if !update.match(/^good\s+#{@ipstatus.ip}$/)
+	  msg = "Error updating host definition for #{@config['hostname']}\n"
+	  msg += "Results:\n#{update}\n"
+	  msg += "Error codes at: https://www.dnsomatic.com/wiki/api"
+	  raise(DNSOMatic::Error, msg)
+	end
+      end
+
+      true
+    end
+
+    # A simple wrapper around update that sets force to true.  The forceful
+    # nature of the update is logged if verbosity is enabled.
+    def update!
+      Logger::log("Forcing update at user request.")
+      update(true)
+    end
+
+    # This is used to simply return the url that would be sent to DNS-o-Matic.
+    # Using this is an easy way to build a list of update URL's that could
+    # be directed elsewhere (a log, or wget, etc).
+    def to_s
+      upd_url
+    end
+	
+    private
+    def upd_url
+      opt_params = %w(wildcard mx backmx offline)
+      u = @config['username']
+      p = @config['password']
+      @ipstatus = @lookup.ip_from_url(@config['webipfetchurl'])
+
+      #we'll use nil as a key from the ip lookup to determine that the ip
+      #hasn't changed, so no update is required.
+      url = "https://#{u}:#{p}@updates.dnsomatic.com/nic/update?"
+      name_ip = "hostname=#{@config['hostname']}&myip=#{@ipstatus.ip}"
+      url += opt_params.inject(name_ip) do |params, curp|
+	val = @config[curp]
+	next if val.eql?('') or val.nil?
+	params += "&#{curp}=#{val}"
+      end
+      url
+    end
+  end
+end #end module

data/tests/all_tests.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby -w
+#
+require 'test/unit'
+
+Dir.glob("test*rb") do |f|
+  require "#{f.sub(/\.rb/, '')}"
+end
+
+

data/tests/test_iplookup.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby -w
+$: << '../lib'
+
+require 'test/unit'
+require 'ostruct'
+
+require 'dnsomatic'
+
+class TestIPLookup < Test::Unit::TestCase
+  def setup
+    $opts = DNSOMatic::Opts.instance
+    $fp = File.join('/tmp', 'dnsomatic.testcache-' + Process.pid.to_s)
+    $iplookup = DNSOMatic::IPLookup.instance
+    $iplookup.setcachefile($fp)
+    $iplookup.persist = false
+    $local = 'http://benandwen.net/~bwalton/ip_lookup.php'
+    $local_ip = %x{wget -q -O - http://benandwen.net/~bwalton/ip_lookup.php}
+    $random = 'http://benandwen.net/~bwalton/ip_rand.php'
+  end
+
+  def test_cache_works
+    stat = $iplookup.ip_from_url($local)
+    assert_equal(DNSOMatic::IPStatus::CHANGED, stat.changed?)
+    assert_equal($local_ip, stat.ip)
+    stat.update
+    assert_equal(DNSOMatic::IPStatus::UNCHANGED, stat.changed?)
+  end
+
+  def test_different_source_returns_new_val
+    stat = $iplookup.ip_from_url($random)
+    assert_equal(DNSOMatic::IPStatus::CHANGED, stat.changed?)
+  end
+
+  def test_known_ip_change_still_prefers_cache
+    #ensure we have a long interval between polls, so we know we get cached ip
+    $opts.parse(%w(-m 1800))
+    stat = $iplookup.ip_from_url($random)
+    assert_equal(DNSOMatic::IPStatus::UNCHANGED, stat.changed?)
+  end
+
+  def test_expiration_with_known_change
+    stat = $iplookup.ip_from_url($random)
+    assert_equal(DNSOMatic::IPStatus::UNCHANGED, stat.changed?)
+    $opts.parse(%w(-m 0)) #change expiration to 2s.
+    sleep(1)  #make sure we pass the expiration time we just set.
+    stat = $iplookup.ip_from_url($random)
+    assert_equal(DNSOMatic::IPStatus::CHANGED, stat.changed?)
+  end
+
+  def test_persist_stores_to_file
+    $iplookup.persist = true
+    stat = $iplookup.ip_from_url($random)
+    assert(File.exists?($fp), "${fp} doesn't exist when persist is enabled.")
+  end
+
+  def teardown
+    File.delete($fp) if File.exists?($fp)
+  end
+end

data/tests/test_ipstatus.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/ruby -w
+$: << '../lib'
+
+require 'test/unit'
+require 'ostruct'
+
+require 'dnsomatic'
+
+class TestIPStatus < Test::Unit::TestCase
+  def setup
+    $opts = DNSOMatic::Opts.instance
+    $opts.parse(%w(-m 0))
+    $local = 'http://benandwen.net/~bwalton/ip_lookup.php'
+    $local_ip = %x{wget -q -O - http://benandwen.net/~bwalton/ip_lookup.php}
+    $random = 'http://benandwen.net/~bwalton/ip_rand.php'
+    $non_lookup = 'http://benandwen.net/~bwalton/non_ip_lookup.txt'
+  end
+
+  def test_returns_right_ip
+    stat = DNSOMatic::IPStatus.new($local)
+    assert_equal($local_ip, stat.ip)
+  end
+
+  def test_returns_right_status
+    stat1 = DNSOMatic::IPStatus.new($local)
+    assert_equal(true, stat1.changed?)
+    stat1.update
+    assert_equal(false, stat1.changed?)
+
+    stat2 = DNSOMatic::IPStatus.new($random)
+    assert_equal(true, stat2.changed?)
+    stat2.update
+    assert_equal(true, stat2.changed?)
+  end
+
+  def test_raise_on_bad_args
+    assert_raise(DNSOMatic::Error) { DNSOMatic::IPStatus.new($non_lookup) }
+  end
+end

data/tests/test_opts.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby -w
+$: << '../lib'
+
+require 'test/unit'
+require 'ostruct'
+
+require 'dnsomatic'
+
+class TestOpts < Test::Unit::TestCase
+  def setup
+    $opts = DNSOMatic::Opts.instance
+  end
+
+  def test_set_verbose
+    $opts.parse(%w(-v))
+    assert($opts.verbose)
+    $opts.parse(%w(--verbose))
+    assert($opts.verbose)
+  end
+
+  def test_set_minimum
+    $opts.parse(%w(-m 10))
+    assert_equal(10, $opts.minimum)
+    $opts.parse(%w(--minimum 15))
+    assert_equal(15, $opts.minimum)
+  end
+
+  def test_set_maximum
+    $opts.parse(%w(-M 10))
+    assert_equal(10, $opts.maximum)
+    $opts.parse(%w(--maximum 15))
+    assert_equal(15, $opts.maximum)
+  end
+
+  def test_set_alert
+    $opts.parse(%w(-a))
+    assert($opts.alert)
+    $opts.parse(%w(--alert))
+    assert($opts.alert)
+  end
+
+  def test_set_name
+    $opts.parse(%w(-n testcase))
+    assert_equal('testcase', $opts.name)
+    $opts.parse(%w(--name testcase2))
+    assert_equal('testcase2', $opts.name)
+  end
+
+  def test_set_display_config
+    $opts.parse(%w(-d))
+    assert($opts.showcf)
+    $opts.parse(%w(--display-config))
+    assert($opts.showcf)
+  end
+
+  def test_set_config_file
+    $opts.parse(%w(-c /tmp/dnsomatic))
+    assert_equal('/tmp/dnsomatic', $opts.cf)
+    $opts.parse(%w(--config /tmp/dnsomatic2))
+    assert_equal('/tmp/dnsomatic2', $opts.cf)
+  end
+
+  def test_set_force
+    $opts.parse(%w(-f))
+    assert($opts.force)
+    $opts.parse(%w(--force))
+    assert($opts.force)
+  end
+
+  def test_extra_opts_raise_exception
+    assert_raise(DNSOMatic::Error) { $opts.parse(%w(--badoption)) }
+  end
+
+  def test_extra_args_raise_exception
+    assert_raise(DNSOMatic::Error) { $opts.parse(%w(somearg)) }
+  end
+
+end

data/tests/test_updater.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby -w
+$: << '../lib'
+
+require 'test/unit'
+require 'ostruct'
+
+require 'dnsomatic'
+
+class TestUpdater < Test::Unit::TestCase
+  def setup
+    $opts = DNSOMatic::Opts.instance
+    $fp = File.join('/tmp', 'dnsomatic.testcache-' + Process.pid.to_s)
+    $iplookup = DNSOMatic::IPLookup.instance
+    $iplookup.setcachefile($fp)
+    $iplookup.persist = false
+    $local = 'http://benandwen.net/~bwalton/ip_lookup.php'
+    $local_ip = %x{wget -q -O - http://benandwen.net/~bwalton/ip_lookup.php}
+    $random = 'http://benandwen.net/~bwalton/ip_rand.php'
+  end
+
+  def giveconf(u, p, mx, bmx, w, o, wf = $local, hn = 'all.dnsomatic.com')
+    { 'username' => u, 'password' => p, 'mx' => mx, 'backmx' => bmx,
+	'wildcard' => w, 'offline' => o , 'webipfetchurl' => wf,
+	'hostname' => hn}
+  end
+
+  def test_config_taken
+    c = giveconf('user', 'mypass', 'NOCHG', 'NOCHG', 'NOCHG', 'NOCHG')
+    url = "https://user:mypass@updates.dnsomatic.com/nic/update?hostname=all.dnsomatic.com&myip=#{$local_ip}&wildcard=NOCHG&mx=NOCHG&backmx=NOCHG&offline=NOCHG"
+    u = DNSOMatic::Updater.new(c)
+    assert_equal(url, u.to_s)
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: dnsomatic
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ben Walton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-26 00:00:00 -04:00
+default_executable: dnsomatic
+dependencies: []
+
+description: 
+email: bdwalton@gmail.com
+executables: 
+- dnsomatic
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/dnsomatic
+- lib/dnsomatic
+- lib/dnsomatic/updater.rb
+- lib/dnsomatic/logger.rb
+- lib/dnsomatic/iplookup.rb
+- lib/dnsomatic/opts.rb
+- lib/dnsomatic/config.rb
+- lib/dnsomatic.rb
+- tests/test_ipstatus.rb
+- tests/test_opts.rb
+- tests/test_updater.rb
+- tests/all_tests.rb
+- tests/test_iplookup.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/dnsomatic
+post_install_message: 
+rdoc_options: 
+- -x tests/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: http://rubyforge.org/projects/dnsomatic
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: A DNS-O-Matic Update Client
+test_files: 
+- tests/all_tests.rb