ganddyn 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0feada86e7855617874d6d329144969022a4c9c
+  data.tar.gz: 7191df63d2bea9643bc2ccdf768d2a72fc9dcc91
+SHA512:
+  metadata.gz: 116d9fe483f702b7c70e690be5801ee37dd821b4008663cc2d8cb79991d62d71dba3dedd4d5ee1f93735ab5740c7d6d59b984d91b34343208ea90fc45de4b6d7
+  data.tar.gz: 66a5d1db13fe7dd1c29bdcee78fd03f3139f3c65065e1405e5bc560c7f0f6f6a3632db5217cefd6496f07e79e7cb22b9686c0da3839b5450330e79cffd99564a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ganddyn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Guillaume Virlet
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+Ganddyn [![Build Status](https://travis-ci.org/doc75/ganddyn.svg?branch=master)](https://travis-ci.org/doc75/ganddyn)
+=======
+
+This gem allows to update your GANDI DNS zone with the current external IPv4 of your machine.
+It duplicate current zone information in the last inactive version of the zone (or a newly
+created one if only one version exist). It updates the IPv4 for the name requested and activate
+this version.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ganddyn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ganddyn
+
+## Usage
+
+    $ gannddyn hostname.domain.com GANDIAPIKEY /path/to/file/storing/last/ip/updated
+
+**Warning**:
+  - This is an early version not fully tested, use it at your own risk.
+  - When used on multiple machines for the same domain, it might miss some update in case of concurrent update
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/ganddyn

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << './lib'
+require 'ganddyn'
+
+raise ArgumentError, 'Usage: ganddyn host.domain.com gandi_api_key yaml_file' if ARGV.size != 3
+
+begin
+  cli = Ganddyn::Client.new({:hostname => ARGV[0], :api_key => ARGV[1], :config_file => ARGV[2]})
+  cli.update
+  retval = 0
+rescue Exception => e
+  puts e
+  puts e.backtrace
+  retval = 1
+end
+
+exit retval

data/ganddyn.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ganddyn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ganddyn'
+  spec.version       = Ganddyn::VERSION
+  spec.authors       = ['Guillaume Virlet']
+  spec.email         = ['github@virlet.org']
+  spec.description   = %q{This gem allows to update your GANDI DNS zone with the current external IPv4 of your machine.
+It duplicate current zone information in the last inactive version of the zone (or a newly
+created one if only one version exist). It updates the IPv4 for the name requested and activate
+this version.}
+  spec.summary       = %q{Update GANDI DNS zone IPv4}
+  spec.homepage      = 'https://github.com/doc75/ganddyn'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~>10.3.1'
+  spec.add_development_dependency 'rspec', '~>2.14.1'
+  spec.add_development_dependency 'webmock', '~>1.17.4'
+
+  spec.add_dependency 'gandi', '~>2.0.10'
+  spec.add_dependency 'highline', '~>1.6.21'
+  spec.add_dependency 'certified', '~> 0.1.2'
+end

data/lib/ganddyn/client.rb

@@ -0,0 +1,297 @@
+require 'gandi'
+
+require 'fileutils'
+require 'yaml'
+require 'highline'
+
+if RUBY_PLATFORM =~ /mingw32/
+  require 'certified'
+end
+
+module Ganddyn
+  class Client
+
+    TTL = 300
+
+    def initialize opts
+      raise ArgumentError, 'opts is not a Hash' unless opts.is_a? Hash
+      raise ArgumentError, 'opts does not contain key :hostname' unless opts.has_key? :hostname
+      raise ArgumentError, 'opts does not contain key :api_key' unless opts.has_key? :api_key
+      raise ArgumentError, 'opts does not contain key :config_file' unless opts.has_key? :config_file
+
+      @debug = false
+
+      @api_key     = opts[:api_key]
+      @config_file = opts[:config_file]
+
+      tab = opts[:hostname].split('.')
+      @name     = tab[0...-2].join('.')
+      @domain   = tab[-2..-1].join('.')
+
+      @terminal = opts.has_key?(:terminal) ? opts[:terminal] : HighLine.new
+
+      begin
+        last_ips_gandi = YAML.load_file @config_file
+        print_debug last_ips_gandi.inspect, 2
+      rescue => e
+        print_debug 'Cannot load config file', 1
+        last_ips_gandi = false
+      end
+
+      if last_ips_gandi
+        print_debug "last_ips_gandi exist", 2
+      else
+        print_debug "last_ips_gandi is nil or false", 2
+      end
+      print_debug last_ips_gandi.inspect, 2
+      @last_ipv4 = (last_ips_gandi && last_ips_gandi[:ipv4].size > 0) ? last_ips_gandi[:ipv4] : nil
+
+      print_debug "Last IPv4 (form config file):#{@last_ipv4}", 1
+
+      @cur_ipv4 = nil
+      @api      = nil
+      @zone_id  = nil
+
+    end
+
+    # return value:
+    #   true  => update done
+    #   false => update not needed
+    #   nil => no network found
+    def update
+      return nil unless ipv4_available?
+
+      last_ipv4 = @last_ipv4 ? @last_ipv4 : get_gandi_ipv4
+
+      update_config = false
+
+      if @last_ipv4.nil?
+        update_config = true
+      else
+        update_config = true if @last_ipv4.empty?
+        update_config = true if last_ipv4 != @last_ipv4
+      end
+
+      print_debug "Last IPv4 (form config file or Gandi):#{last_ipv4}", 1
+
+      # TODO: save it in YAML file to reduce Gandi queries
+      ip_resolv = IpResolver.new
+      cur_ipv4 = ipv4_available? ? ip_resolv.get_ipv4 : ''
+
+      if !cur_ipv4.empty? && cur_ipv4 != last_ipv4
+        to_update = cur_ipv4
+        update_config = true
+      else
+        to_update = ''
+      end
+
+      print_debug to_update.inspect, 2
+      retval = update_ips to_update
+      if retval and update_config
+        retval = update_config_file cur_ipv4
+      end
+      retval
+    end
+
+    private
+      # return value:
+      #   nil => no network available for IPv4
+      #   ''  => no previous IPv4 stored in Ganddi DNS
+      #   otherwise return IPv4 address as a string
+      def get_gandi_ipv4
+        get_record('A') if ipv4_available?
+      end
+
+      def get_ping_option
+        if RUBY_PLATFORM =~ /mingw32/
+          return '-n', '> NUL'
+        else
+          return '-c', '> /dev/null 2>&1'
+        end
+      end
+
+      def ipv4_available?
+        return @ipv4_avail unless @ipv4_avail.nil?
+
+        opt, out = get_ping_option
+        @ipv4_avail = system("ping #{opt} 1 8.8.8.8 #{out}")
+        if @ipv4_avail
+          print_info 'IPv4 network available'
+        else
+          print_info 'IPv4 network not available'
+        end
+        @ipv4_avail
+      end
+
+      def get_record type
+        raise ArgumentError, %Q{type is not 'A'} unless type == 'A'
+        res = gandi_api.domain.zone.record.list(get_zone_id, 0, {:name => @name, :type => type})
+        print_debug res.inspect, 2
+        if res.size == 0
+          print_debug "record not found: '#{@name}'", 1
+          ''
+        else
+          print_debug "record found: '#{@name}' => #{res[0].value}", 1
+          res[0].value
+        end
+      end
+
+      def update_ips update
+
+        raise(ArgumentError, 'update is not a String') unless update.is_a? String
+
+        if update.size == 0
+          print_info 'no update needed'
+          return true
+        end
+
+        cur_vers, all_vers = get_zone_version
+        if all_vers.size == 1
+          # create a new version and add it to list of all versions
+          new_vers = create_new_zone_version
+        else
+          all_vers = all_vers - [cur_vers]
+          # we take the last version of existing versions (my choice ;-)
+          new_vers = all_vers[-1]
+          clone_zone_version( cur_vers, new_vers )
+        end
+        
+        retval = false
+        if update_ipv4(new_vers, update)
+          if activate_updated_version new_vers
+            retval = true
+            print_info 'update done'
+          else
+            retval = false
+            print_info 'update FAILED'
+          end
+        end
+        retval
+      end
+
+      def activate_updated_version version
+        res = gandi_api.domain.zone.version.set(get_zone_id, version)
+        if res
+          print_debug 'activation of zone version successful', 1
+        else
+          print_debug 'activation of zone version failed', 1
+        end
+        res
+      end
+
+      def update_ipv4 zone_version, ip
+        update_record zone_version, ip, 'A'
+      end
+
+      def update_record zone_version, ip, type
+        return false if ip.empty?
+        retval = false
+        records = gandi_api.domain.zone.record.list( get_zone_id,
+                                                     zone_version,
+                                                     {:name => @name, :type => type} )
+        if records.size == 0
+          res = gandi_api.domain.zone.record.add( get_zone_id,
+                                                  zone_version,
+                                                  { :name  => @name,
+                                                    :type  => type,
+                                                    :value => ip,
+                                                    :ttl   => TTL } )
+          retval = true
+        else
+          records.each do |rec|
+            # only update if ip is different
+            if rec.value != ip
+              res = gandi_api.domain.zone.record.update( get_zone_id,
+                                                         zone_version,
+                                                         { :id => rec.id },
+                                                         { :name  => rec.name,
+                                                           :type  => rec.type,
+                                                           :value => ip,
+                                                           :ttl   => TTL } )
+              retval = true
+            end
+          end
+        end
+        retval
+      end
+
+      def clone_zone_version src, dest
+        src_list = gandi_api.domain.zone.record.list(get_zone_id, src)
+        print_debug src_list.inspect, 2
+
+        dest_list = gandi_api.domain.zone.record.list(get_zone_id, dest)
+        print_debug dest_list.inspect, 2
+
+        dest_list.each do |elt|
+
+          curs = src_list.select { |e| e.name == elt.name && e.type == elt.type }
+
+          if curs.size > 0
+            print_debug "\n#{curs.inspect}", 2
+            # normally with the same name and same type we should have only 1 record
+            cur = curs[0]
+
+            if cur.ttl != elt.ttl || cur.value != elt.value
+              print_debug "Updating record (name: #{elt.name} - type: #{elt.type}) to ttl: #{cur.ttl} - value: #{cur.value}", 1
+              res = gandi_api.domain.zone.record.update( get_zone_id, dest, { :id => elt.id }, {:name => cur.name, :type => cur.type, :value => cur.value, :ttl => cur.ttl} )
+              print_debug res.inspect, 2
+            else
+              print_debug "record (name: #{elt.name} - type: #{elt.type}) already up-to-date", 1
+            end
+
+            src_list = src_list - [cur]
+
+          else
+            # it does not exist in current zone, let's delete this record
+            print_debug "\nDeleting record (name: #{elt.name} - type: #{elt.type})", 1
+            res = gandi_api.domain.zone.record.delete( get_zone_id, dest, { :id => elt.id } )
+            
+            if res == 1
+              print_debug "Deletion OK", 2
+            else
+              print_debug "ERROR: deletion of #{res} records", 2
+            end
+          end
+        end
+
+        src_list.each do |cur|
+          print_debug "Creating record (name: #{cur.name} - type: #{cur.type} - ttl: #{cur.ttl} - value: #{cur.value}", 1
+          res = gandi_api.domain.zone.record.add( get_zone_id, dest, {:name => cur.name, :type => cur.type, :value => cur.value, :ttl => cur.ttl} )
+        end
+      end
+
+      def update_config_file ip
+        if File.open(@config_file, 'w+') { |f| f.write({:ipv4 => ip}.to_yaml) }
+          true
+        else
+          false
+        end
+      end
+
+      def get_zone_version
+        get_zone_id
+        infos = gandi_api.domain.zone.info(@zone_id)
+        return infos.version, infos.versions
+      end
+
+      def create_new_zone_version
+        gandi_api.domain.zone.version.new_version(@zone_id)
+      end
+
+      def get_zone_id
+        @zone_id ||= gandi_api.domain.info(@domain).zone_id
+      end
+
+      def gandi_api
+        @api ||= Gandi::Session.new(@api_key)
+      end
+
+      def print_info str
+        @terminal.say str
+      end
+
+      def print_debug str, level = 1
+        @terminal.say str if @debug and @debug >= level
+      end
+  end
+end

data/lib/ganddyn/ipresolver.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+
+module Ganddyn
+
+  class IpResolver
+
+    # urls: hash or ipv4 and ipv6 url services
+    #       { :ipv4 => 'http://ipv4_url', :ipv6 => 'http://ipv6_url'}
+    def initialize urls = {}
+      raise ArgumentError, 'urls is not a Hash' unless urls.is_a? Hash
+
+      @ipv4_url = urls.has_key?(:ipv4) ? urls[:ipv4] : "http://v4.ipv6-test.com/api/myip.php"
+      @ipv6_url = urls.has_key?(:ipv6) ? urls[:ipv6] : "http://v6.ipv6-test.com/api/myip.php"
+    end
+
+    def get_ipv4
+      get_url @ipv4_url
+    end
+
+    def get_ipv6
+      get_url @ipv6_url
+    end
+
+    private
+      def get_url( iUrl )
+        retval = nil
+        uri = URI(iUrl)
+        begin
+          res = Net::HTTP.get_response(uri)
+          if res.code == '200'
+            retval = res.body
+          end
+        rescue SocketError => e
+          # normally it happens if the server name is invalid
+          # or if no network is available
+          # let's return nil
+        rescue Exception => e
+          # normally it happen if the machine has no ipv6 support
+          # let's return nil
+        end
+        retval
+      end
+  end
+end

data/lib/ganddyn/version.rb

@@ -0,0 +1,3 @@
+module Ganddyn
+  VERSION = "0.0.1"
+end

data/lib/ganddyn.rb

@@ -0,0 +1,5 @@
+# Add the directory containing this file to the start of the load path if it isn't there already.
+#$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'ganddyn/ipresolver'
+require 'ganddyn/client'

data/spec/lib/ganddyn/client_spec.rb

@@ -0,0 +1,559 @@
+require 'spec_helper'
+
+require 'ganddyn'
+
+describe Ganddyn::Client do
+  before :each do
+    @input = StringIO.new
+    @output = StringIO.new
+    @terminal = HighLine.new(@input, @output)
+
+    @ipv4 = '12.34.56.78'
+
+    @cur_ver = 123
+    @other_ver = 456
+    @vers = [@cur_ver, @other_ver]
+
+    @mash   = Hashie::Mash.new({:version => @cur_ver, :versions => [@cur_ver, @other_ver]})
+    @domain = 'domain.com'
+    @name   = 'rspec'
+
+    @host = { :hostname    => 'rspec.domain.com' }
+    @key  = { :api_key     => 'FAKEAPIKEY' }
+    @cfg  = { :config_file => '/etc/ganddyn.yaml' }
+    @param = @host.merge(@key).merge(@cfg)
+    allow(YAML).to receive(:load_file).and_return({:ipv4 => @ipv4})
+
+    @api = double('api_gandi')
+    allow(@api).to receive(:domain).and_return(@api)
+    allow(@api).to receive(:zone).and_return(@api)
+    allow(@api).to receive(:info).and_return(@mash)
+
+    allow(@api).to receive(:version).and_return(@api)
+    allow(@api).to receive(:new_version).and_return(3)
+
+    allow(@api).to receive(:record).and_return(@api)
+    allow(@api).to receive(:add).and_return([])
+    allow(@api).to receive(:delete).and_return(1)
+    allow(@api).to receive(:update).and_return([])
+    allow(@api).to receive(:list).and_return([])
+
+    allow(@api).to receive(:version).and_return(@api)
+    allow(@api).to receive(:set).and_return(true)
+
+    allow_any_instance_of(Ganddyn::Client).to receive(:update_config_file).and_return(true)
+  end
+
+  describe '#initialize' do
+    before :each do
+    end
+    it 'takes 1 parameters' do
+      Ganddyn::Client.new( @param ).should be_a Ganddyn::Client
+    end
+
+    it 'raises an error if parameter opts is not a Hash' do
+      expect { Ganddyn::Client.new('rspec.domain.com') }.to raise_error(ArgumentError, /opts is not a Hash/)
+    end
+
+    it 'raises an error if parameter opts does not contain :hostname key' do
+      expect { Ganddyn::Client.new( {:host_name => 'rspec.domain.com'}.merge(@key).merge(@cfg)) }.to raise_error(ArgumentError, /opts does not contain key :hostname/)
+    end
+
+    it 'raises an error if parameter opts does not contain :api_key key' do
+      expect { Ganddyn::Client.new({:apikey => 'FAKEAPIKEY'}.merge(@host).merge(@cfg)) }.to raise_error(ArgumentError, /opts does not contain key :api_key/)
+    end
+
+    it 'raises an error if parameter opts does not contain :config_file key' do
+      expect { Ganddyn::Client.new({ :configfile => '/etc/ganddyn.yaml'}.merge(@host).merge(@key)) }.to raise_error(ArgumentError, /opts does not contain key :config_file/)
+    end
+
+    it 'loads the config file' do
+      expect(YAML).to receive(:load_file).with(@cfg[:config_file]).and_return({:ipv4 => @ipv4})
+      Ganddyn::Client.new( @param )
+    end
+  end
+
+  describe '#update' do
+    before :each do
+      allow_any_instance_of(Ganddyn::IpResolver).to receive(:get_ipv4).and_return('11.22.33.44')
+      @gand = Ganddyn::Client.new( @param.merge({:terminal => @terminal}) )
+      allow(@gand).to receive(:gandi_api).and_return(@api)
+      allow(@gand).to receive(:system).and_return(true)
+    end
+
+    context 'when yaml config file is not found' do
+      before :each do
+        expect(YAML).to receive(:load_file).and_return(false)
+        @gand = Ganddyn::Client.new( @param.merge({:terminal => @terminal}) )
+        allow(@gand).to receive(:gandi_api).and_return(@api)
+        allow(@gand).to receive(:system).and_return(true)
+        allow(@gand).to receive(:get_record)
+      end
+
+      it 'asks gandi for ipv4' do
+        expect(@gand).to receive(:get_record).with('A').and_return(@ipv4)
+        expect(@gand.update).to be_true
+      end
+
+    end
+
+    context 'when yaml config file exist' do
+      it 'does not ask Gandi' do
+        allow(@gand).to receive(:get_record)
+        expect(@gand.update).to be_true
+        expect(@gand).to_not have_received(:get_record)
+      end
+    end
+
+    context 'when no network' do
+      before :each do
+        allow(@gand).to receive(:system).and_return(false)
+      end
+
+      it 'does not ask for IPv4 information' do
+        expect_any_instance_of(Ganddyn::IpResolver).to_not receive(:get_ipv4)
+        expect(@gand.update).to be_nil
+      end
+    end
+
+    context 'when no ip to update' do
+      before :each do
+        allow_any_instance_of(Ganddyn::IpResolver).to receive(:get_ipv4).and_return('')
+      end
+
+      it 'returns true' do
+        expect(@gand.update).to be_true
+      end
+
+      it 'does not modify the yaml config file' do
+        expect(@gand).to_not receive(:update_config_file)
+        @gand.update
+      end
+    end
+
+    context 'when ip to update' do
+      it 'updates the ip' do
+        expect(@gand.update).to be_true
+      end
+
+      it 'updates the yaml config file content' do
+        expect(@gand).to receive(:update_config_file).and_return(true)
+        @gand.update
+      end
+    end
+  end
+
+end
+
+describe_internally Ganddyn::Client do
+  before :each do
+    @input = StringIO.new
+    @output = StringIO.new
+    @terminal = HighLine.new(@input, @output)
+
+    @ipv4 = '12.34.56.78'
+
+    @cur_ver = 123
+    @other_ver = 456
+    @vers = [@cur_ver, @other_ver]
+
+    @mash   = Hashie::Mash.new({:version => @cur_ver, :versions => @vers})
+    @domain = 'domain.com'
+    @name   = 'rspec'
+
+    @host = { :hostname    => 'rspec.domain.com' }
+    @key  = { :api_key     => 'FAKEAPIKEY' }
+    @cfg  = { :config_file => '/etc/ganddyn.yaml' }
+    @param = @host.merge(@key).merge(@cfg)
+    allow(YAML).to receive(:load_file).and_return({:ipv4 => @ipv4})
+
+    @api = double('api_gandi')
+    allow(@api).to receive(:domain).and_return(@api)
+    allow(@api).to receive(:zone).and_return(@api)
+    allow(@api).to receive(:info).and_return(@mash)
+
+    allow(@api).to receive(:version).and_return(@api)
+    allow(@api).to receive(:new_version).and_return(3)
+
+    allow(@api).to receive(:record).and_return(@api)
+    allow(@api).to receive(:add).and_return([])
+    allow(@api).to receive(:delete).and_return(1)
+    allow(@api).to receive(:update).and_return([])
+    allow(@api).to receive(:list).and_return([])
+
+    allow(@api).to receive(:version).and_return(@api)
+    allow(@api).to receive(:set).and_return(true)
+
+    @gand = Ganddyn::Client.new( @param.merge({:terminal => @terminal}) )
+    allow(@gand).to receive(:gandi_api).and_return(@api)
+    allow(@gand).to receive(:system).and_return(true)
+
+    allow_any_instance_of(Ganddyn::Client).to receive(:update_config_file).and_return(true)
+  end
+
+  describe '#get_zone_id' do
+    it 'returns the current zone id' do
+      @api.should_receive(:info).with(@domain).and_return(Hashie::Mash.new({:zone_id => 666}))
+      @gand.get_zone_id.should == 666
+    end
+
+    it 'calls gandi api only once' do
+      @api.should_receive(:info).once.with(@domain).and_return(Hashie::Mash.new({:zone_id => 666}))
+      @gand.get_zone_id.should == 666
+      @gand.get_zone_id.should == 666
+    end
+  end
+
+  describe '#create_new_zone_version' do
+    pending 'not really necessary'
+  end
+
+  describe '#get_zone_version' do
+    it 'returns 2 values' do
+      version, versions = @gand.get_zone_version
+      version.should == @cur_ver
+      versions.should == @vers
+    end
+  end
+
+  describe '#get_record' do
+    before :each do
+      @type   = 'A'
+      @filter = { :name => @name, :type => @type }
+      @res    = Hashie::Mash.new({:value => @ipv4})
+    end
+
+    it 'takes 1 parameter as argument' do
+      @api.should_receive(:list).with(anything(), 0, @filter).and_return([@res])
+      @gand.get_record('A')
+    end
+
+    context 'when Gandi returns a record' do
+      before :each do
+        expect(@api).to receive(:list).with(anything(), 0, @filter).and_return([@res])
+      end
+
+      it 'returns the IPv4 address' do
+        @gand.get_record('A').should == @ipv4
+      end
+
+      # it 'output record found with value' do
+      #   @gand.get_record('A')
+      #   expect(@output.string).to match /record found: '#{@name}' => #{@ipv4}/
+      # end
+    end
+
+    context 'when Gandi returns no record' do
+      before :each do
+        expect(@api).to receive(:list).with(anything(), 0, @filter).and_return([])
+      end
+
+      it 'returns an empty string if Gandi returns no record' do
+        expect(@gand.get_record('A')).to eq ''
+      end
+
+      # it 'output "record not found"' do
+      #   @gand.get_record('A')
+      #   expect(@output.string).to match /record not found: '#{@name}'/
+      # end
+    end
+
+    it 'raises an error if type is not A' do
+      expect { @gand.get_record('AA') }.to raise_error(ArgumentError, /type is not 'A'/)
+    end
+  end
+
+  describe '#get_gandi_ipv4' do
+    before :each do
+      @type   = 'A'
+      @filter = { :name => @name, :type => @type }
+      @res    = Hashie::Mash.new({:value => @ipv4})
+    end
+
+    it 'retrieve the record A from Gandi DNS' do
+      expect(@api).to receive(:list).with(anything(), 0, @filter).and_return([@res])
+      expect(@gand.get_gandi_ipv4).to eq @ipv4
+    end
+
+    it 'returns nil if IPv4 network is not available' do
+      allow(@gand).to receive(:get_record).and_return('1.2.3.4')
+      expect(@gand).to receive(:ipv4_available?).and_return(false)
+      expect(@gand.get_gandi_ipv4).to be_nil
+      expect(@gand).to_not have_received(:get_record)
+    end
+  end
+
+  describe '#update_record' do
+    before :each do
+      @type = 'A'
+      @rec  = { :name => @name, :type => @type, :value => @ipv4, :ttl => Ganddyn::Client::TTL }
+
+    end
+
+    it 'takes 3 arguments' do
+      expect(@gand.update_record( @cur_ver, @ipv4, 'A')).to be_true
+    end
+
+    context 'when input ip is empty' do
+      it 'returns false' do
+        expect(@gand.update_record( @cur_ver, '', 'A')).to be_false
+      end
+    end 
+
+    context 'when record does not exist yet' do
+      it 'adds a new record' do
+        expect(@gand.update_record( @cur_ver, @ipv4, 'A')).to be_true
+        expect(@api).to have_received(:add).with(anything, @cur_ver, @rec )
+        expect(@api).to_not have_received(:update)
+      end
+    end
+
+    context 'when record already exist' do
+      before :each do
+        @filter = { :name => @name, :type => @type }
+        @res    = Hashie::Mash.new({:value => @ipv4})
+        expect(@api).to receive(:list).with(anything(), @cur_ver, @filter).and_return([@res])
+      end
+
+      context 'and ip is different' do
+        it 'updates the record' do
+          @gand.update_record( @cur_ver, "#{@ipv4}1", 'A')
+          expect(@api).to_not have_received(:add)
+          expect(@api).to have_received(:update).once
+        end
+
+        it 'returns true' do
+          expect(@gand.update_record( @cur_ver, "#{@ipv4}1", 'A')).to be_true
+        end
+      end
+
+      context 'and ip is the same' do
+        it 'does not update the record' do
+          @gand.update_record( @cur_ver, @ipv4, 'A')
+          expect(@api).to_not have_received(:add)
+          expect(@api).to_not have_received(:update)
+        end
+
+        it 'returns false' do
+          expect(@gand.update_record( @cur_ver, @ipv4, 'A')).to be_false
+        end
+      end
+    end
+  end
+
+  describe '#clone_zone_version' do
+    before :each do
+      @src = 111
+      @src_ret = [ 123, 456 ].map do |id|
+                    Hashie::Mash.new({ :id    => id,
+                                       :name  => "name#{id}",
+                                       :type  => "type#{id}",
+                                       :value => "value#{id}",
+                                       :ttl   => "ttl#{id}" })
+                  end
+      @dest = 222
+      @dest_ret = [ 123, 789 ].map do |id|
+                    Hashie::Mash.new({ :id    => id,
+                                       :name  => "name#{id}",
+                                       :type  => "type#{id}",
+                                       :value => "value#{id}-dest",
+                                       :ttl   => "ttl#{id}-dest" })
+                  end
+      allow(@api).to receive(:list).with(anything(), @src).and_return(@src_ret)
+      allow(@api).to receive(:list).with(anything(), @dest).and_return(@dest_ret)
+    end
+
+    it 'get the information from source zone' do
+      expect(@api).to receive(:list).with(anything(), @src).and_return(@src_ret)
+      @gand.clone_zone_version @src, @dest
+    end
+    
+    it 'get the information from destination zone' do
+      expect(@api).to receive(:list).with(anything(), @dest).and_return(@dest_ret)
+      @gand.clone_zone_version @src, @dest
+    end
+
+    it 'deletes the record existing in destination zone but not in source zone' do
+      expect(@api).to receive(:delete).with(anything(), @dest, {:id => 789})
+      @gand.clone_zone_version @src, @dest
+    end
+
+    it 'update the record existing in both zone' do
+      ret = @src_ret[0].to_hash.inject({}) { |acc,(k,v)| acc[k.to_sym] = v if k != 'id'; acc }
+      expect(@api).to receive(:update).with(anything(), @dest, {:id => 123}, ret)
+      @gand.clone_zone_version @src, @dest
+    end
+
+    it 'create the record existing only in source zone' do
+      ret = @src_ret[1].to_hash.inject({}) { |acc,(k,v)| acc[k.to_sym] = v if k != 'id'; acc }
+      expect(@api).to receive(:add).with(anything(), @dest, ret)
+      @gand.clone_zone_version @src, @dest
+    end
+  end
+
+  describe '#activate_updated_version' do
+    context 'when activation succeeded' do
+      it 'returns true' do
+        expect(@gand.activate_updated_version(2)).to be_true
+      end
+
+      # it 'output activation of zone version successful' do
+      #   @gand.activate_updated_version(2)
+      #   expect(@output.string).to match /activation of zone version successful/
+      # end
+    end
+
+    context 'when activation failed' do
+      before :each do
+        expect(@api).to receive(:set).with(anything(), 9).and_return(false)
+      end
+      it 'returns false' do
+        expect(@gand.activate_updated_version(9)).to be_false
+      end
+
+      # it 'output activation of zone version failed' do
+      #   @gand.activate_updated_version(9)
+      #   expect(@output.string).to match /activation of zone version failed/
+      # end
+
+    end
+  end
+
+  describe '#update_ipv4' do
+    # pending 'not necessary'
+  end
+
+
+  describe '#update_ips' do
+    it 'take 1 input as parameter' do
+      expect(@gand.update_ips('')).to be_true
+    end
+
+    context 'when input is not a String' do
+      it 'raise an error' do
+        expect{ @gand.update_ips(['1.2.3.4']) }.to raise_error(ArgumentError, /update is not a String/)
+      end
+    end
+
+    context 'when no ip to update' do
+      it 'returns true without doing anything' do
+        allow(@gand).to receive(:get_zone_version)
+        allow(@gand).to receive(:create_new_zone_version)
+        allow(@gand).to receive(:clone_zone_version)
+
+        expect(@gand.update_ips('')).to be_true
+
+        expect(@gand).to_not have_received(:get_zone_version)
+        expect(@gand).to_not have_received(:create_new_zone_version)
+        expect(@gand).to_not have_received(:clone_zone_version)
+      end
+
+      it 'output no update needed' do
+        @gand.update_ips('')
+        expect(@output.string).to match /no update needed/
+      end
+    end
+
+    context 'when ipv4 to update' do
+
+      it 'updates ipv4 record' do
+        expect(@gand).to receive(:update_ipv4).and_return(true)
+        @gand.update_ips '1.2.3.4'
+      end
+
+      context 'when activation of new zone version is OK' do
+        it 'returns true' do
+          expect(@gand.update_ips('1.2.3.4')).to be_true
+        end
+
+        it 'output update done' do
+          @gand.update_ips('1.2.3.4')
+          expect(@output.string).to match /update done/
+        end
+      end
+
+      context 'when activation of new zone version is KO' do
+        before :each do
+          expect(@gand).to receive(:get_zone_version).and_return([666, [666]])
+          expect(@api).to receive(:set).with(anything(), 3).and_return(false)
+        end
+
+        it 'returns false' do
+          expect(@gand.update_ips('1.2.3.4')).to be_false
+        end
+
+        it 'output update FAILED' do
+          @gand.update_ips('1.2.3.4')
+          expect(@output.string).to match /update FAILED/
+        end
+      end
+
+      it 'activate the new zone version' do
+        expect(@gand).to receive(:activate_updated_version).and_return(true)
+        @gand.update_ips '1.2.3.4'
+      end
+    end
+
+    context 'when only 1 zone version exists' do
+      it 'creates a new version for the zone from current active version' do
+        allow(@gand).to receive(:clone_zone_version)
+        mash = Hashie::Mash.new({:version => 1, :versions => [1]})
+        allow(@api).to receive(:info).and_return(mash)
+        expect(@api).to receive(:new_version).and_return(99)
+
+        @gand.update_ips('1.2.3.4')
+
+        expect(@gand).to_not receive(:clone_zone_version)
+      end
+    end
+
+    context 'when more than 1 zone version exist' do
+      it 'clone the last non active version of the zone' do
+        expect(@gand).to receive(:clone_zone_version)
+        @gand.update_ips('1.2.3.4')
+        expect(@api).to_not receive(:new_version)
+      end
+    end
+  end
+
+  describe '#ipv4_available' do
+    context 'when network is not available' do
+      before :each do
+        allow(@gand).to receive(:system).and_return(false)
+      end
+
+      it 'returns false' do
+        expect(@gand.ipv4_available?).to be false
+      end
+
+      it 'output IPv4 network not available' do
+        @gand.ipv4_available?
+        expect(@output.string).to match /IPv4 network not available/
+      end
+    end
+
+    context 'when network is available' do
+      it 'returns true' do
+        expect(@gand.ipv4_available?).to be true
+      end
+
+      it 'output IPv4 network available' do
+        @gand.ipv4_available?
+        expect(@output.string).to match /IPv4 network available/
+      end
+    end
+
+    context 'on windows platform' do
+      it 'redirect output to > NUL' do
+        pending
+      end
+    end
+
+    context 'on Linux platform' do
+      it 'redirect output to > /dev/null 2>&1' do
+        pending
+      end
+    end
+  end
+
+end

data/spec/lib/ganddyn/ipresolver_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+require 'ganddyn'
+
+describe Ganddyn::IpResolver do
+
+  before :each do
+    @ip = Ganddyn::IpResolver.new( { :ipv4 => 'http://v4.rspec.domain.com', :ipv6 => 'http://v6.rspec.domain.com' } )
+  end
+
+  context '#intialize' do
+    it 'takes 0 parameter' do
+      Ganddyn::IpResolver.new.should be_a Ganddyn::IpResolver
+    end
+
+    it 'take 1 parameter' do
+      Ganddyn::IpResolver.new({}).should be_a Ganddyn::IpResolver
+    end
+
+    it 'raises an error if parameter is not Hash' do
+      expect { Ganddyn::IpResolver.new([]) }.to raise_error(ArgumentError, /urls is not a Hash/)
+    end
+  end
+
+  context '#get_ipv4' do
+    it 'returns the ipv4' do  
+      stub_request(:get, 'v4.rspec.domain.com').to_return(:body => '1.2.3.4', :status => 200, :headers => { 'Content-Length' => 3 })
+      @ip.get_ipv4.should == '1.2.3.4'
+    end
+
+    it 'returns empty string if client has no ipv4' do
+      stub_request(:get, 'v4.rspec.domain.com').to_raise(Exception)
+      @ip.get_ipv4.should be_nil
+    end
+
+    it 'returns nil if server is not reachable' do
+      stub_request(:get, 'v4.rspec.domain.com').to_raise(SocketError)
+      @ip.get_ipv4.should be_nil
+    end
+
+    it 'returns nil if url is incorrect' do
+      stub_request(:get, 'v4.rspec.domain.com').to_return(:body => '<html><head>
+<title>404 Not Found</title>
+</head><body>
+<h1>Not Found</h1>
+<p>The requested URL xxx was not found on this server.</p>
+<hr>
+</body></html>', :status => 404, :headers => { 'Content-Length' => 3 })
+      @ip.get_ipv4.should be_nil
+    end
+  end
+
+  context '#get_ipv6' do
+    it 'returns the ipv6' do
+      stub_request(:get, 'v6.rspec.domain.com').to_return(:body => '3b12:d24:1e6a:8e81:b6a2:6f67:5627:bf44', :status => 200, :headers => { 'Content-Length' => 3 })
+      @ip.get_ipv6.should == '3b12:d24:1e6a:8e81:b6a2:6f67:5627:bf44'
+    end
+
+    it 'returns nil if client has no ipv6' do
+      stub_request(:get, 'v6.rspec.domain.com').to_raise(Exception)
+      @ip.get_ipv6.should be_nil
+
+    end
+
+    it 'returns nil if server is not reachable' do
+      stub_request(:get, 'v6.rspec.domain.com').to_raise(SocketError)
+      @ip.get_ipv6.should be_nil
+    end
+
+    it 'returns nil if url is incorrect' do
+      stub_request(:get, 'v6.rspec.domain.com').to_return(:body => '<html><head>
+<title>404 Not Found</title>
+</head><body>
+<h1>Not Found</h1>
+<p>The requested URL xxx was not found on this server.</p>
+<hr>
+</body></html>', :status => 404, :headers => { 'Content-Length' => 3 })
+      @ip.get_ipv6.should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require 'webmock/rspec'
+
+# enable to test private method of a class
+def describe_internally *args, &block
+  example = describe *args, &block
+  cur_class = args[0]
+  if cur_class.is_a? Class
+    saved_private_instance_methods = cur_class.private_instance_methods
+    example.before do
+      cur_class.class_eval { public *saved_private_instance_methods }
+    end
+    example.after do
+      cur_class.class_eval { private *saved_private_instance_methods }
+    end
+  end
+end
+

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: ganddyn
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Guillaume Virlet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.17.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.17.4
+- !ruby/object:Gem::Dependency
+  name: gandi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+- !ruby/object:Gem::Dependency
+  name: certified
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+description: |-
+  This gem allows to update your GANDI DNS zone with the current external IPv4 of your machine.
+  It duplicate current zone information in the last inactive version of the zone (or a newly
+  created one if only one version exist). It updates the IPv4 for the name requested and activate
+  this version.
+email:
+- github@virlet.org
+executables:
+- ganddyn
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ganddyn
+- ganddyn.gemspec
+- lib/ganddyn.rb
+- lib/ganddyn/client.rb
+- lib/ganddyn/ipresolver.rb
+- lib/ganddyn/version.rb
+- spec/lib/ganddyn/client_spec.rb
+- spec/lib/ganddyn/ipresolver_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/doc75/ganddyn
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Update GANDI DNS zone IPv4
+test_files:
+- spec/lib/ganddyn/client_spec.rb
+- spec/lib/ganddyn/ipresolver_spec.rb
+- spec/spec_helper.rb