wamupd 1.1.1

data/lib/wamupd/dns_avahi_controller.rb

@@ -0,0 +1,230 @@
+# Copyright (C) 2009-2010 James Brown <roguelazer@roguelazer.com>.
+#
+# This file is part of wamupd.
+#
+# wamupd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wamupd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with wamupd.  If not, see <http://www.gnu.org/licenses/>.
+
+require "wamupd/action"
+require "wamupd/avahi_service"
+require "wamupd/dns_update"
+require "wamupd/lease_update"
+require "wamupd/main_settings"
+require "wamupd/signals"
+
+require "algorithms"
+require "dnsruby"
+require "thread"
+
+# Wamupd is a module that is used to namespace all of the wamupd code.
+module Wamupd
+    # Duplicate services were registered with the controller.
+    # Should almost certainly be treated as non-fatal
+    class DuplicateServiceError < StandardError
+    end
+
+    # Coordinate between a set of Avahi Services and DNS records
+    #
+    # == Signals
+    #
+    # [:added] 
+    #    Raised when a new service is added to the controller and
+    #    successfully registered.  has two parameters: the AvahiService
+    #    added and the queue ID of the DNS request (or <tt>true</tt> if the
+    #    request was synchronous)
+    #
+    # [:deleted]
+    #    Raised when a service is deleted from the controller. Contains
+    #    the deleted service as its parameter
+    #
+    # [:renewed] 
+    #    Raised when a service's lease is renewed. Contains the renewed
+    #    service as its parameter
+    #
+    # [:quit]
+    #    Raised when the controller is quitting
+    class DNSAvahiController
+        include Wamupd::Signals
+
+        # A queue to put actions into.
+        attr_reader :queue
+
+        # Initialize the controller.
+        def initialize()
+            @sa = MainSettings.instance
+            # Services stored as a hash from 
+            @services = {}
+            @resolver = @sa.resolver
+            @added = []
+            @queue = Queue.new
+            # Make a min priority queue for leases
+            @lease_queue = Containers::PriorityQueue.new { |x,y| (x<=>y) == -1 }
+        end
+
+        # Add an array of services to the controller
+        def add_services(services)
+            services.each { |s| add_service(s) }
+        end
+
+        # Add a single service record to the controller
+        def add_service(service)
+            if service.kind_of?(AvahiService)
+                if (not @services.has_key?(service.identifier))
+                    @services[service.identifier] = service
+                else
+                    raise DuplicateServiceError.new("Got a duplicate")
+                end
+            elsif (service.kind_of?(AvahiServiceFile))
+                service.each { |service_entry|
+                    add_service(service_entry)
+                }
+            else
+                raise ArgumentError.new("Not an AvahiService")
+            end
+        end
+
+        # Delete a signle service record from the service
+        def delete_service(service)
+            if service.kind_of?(AvahiService)
+                @services.delete(service.identifier)
+            else
+                raise ArgumentError.new("Not an AvahiService")
+            end
+        end
+
+        # Return the number of elements in the controller
+        def size
+            return @services.size
+        end
+
+        # Keys
+        def keys
+            return @services.keys
+        end
+
+        # Publish all currently stored records
+        def publish_all
+            ids = []
+            @services.each { |key,service|
+                ids << publish(service)
+            }
+            return ids
+        end
+
+        # Unpublish all stored records
+        def unpublish_all
+            todo = []
+            @services.each { |key,service|
+                todo << { :target=>service.type_in_zone_with_name, 
+                    :type=>Dnsruby::Types.SRV,
+                    :value=> "#{@sa.priority} #{@sa.weight} #{service.port} #{service.target}"}
+                todo << { :target=>service.type_in_zone, 
+                    :type=>Dnsruby::Types.PTR,
+                    :value=>service.type_in_zone_with_name}
+                todo << { :target=>service.type_in_zone_with_name,
+                    :type=>Dnsruby::Types.TXT}
+            }
+            DNSUpdate.unpublish_all(*todo)
+        end
+
+        # Publish a single service
+        #
+        # Returns: the DNS request ID
+        def publish(service, ttl=@sa.ttl, lease_time=@sa.lease_time)
+            to_update = []
+            to_update << {:target=>service.type_in_zone,
+                :type=>Dnsruby::Types.PTR, :ttl=>ttl,
+                :value=>service.type_in_zone_with_name}
+            to_update << {:target=>service.type_in_zone_with_name,
+                :type=>Dnsruby::Types.SRV, :ttl=>ttl,
+                :value=> "#{@sa.priority} #{@sa.weight} #{service.port} #{service.target}"}
+            # why doesn't Ruby have !==
+            unless (service.txt === false)
+                to_update << {:target => service.type_in_zone_with_name,
+                    :type=>Dnsruby::Types.TXT, :ttl=>ttl,
+                    :value=>service.txt}
+            end
+            update_time = Time.now() + lease_time
+            @lease_queue.push(Wamupd::LeaseUpdate.new(update_time, service), update_time)
+            return DNSUpdate.publish_all(to_update)
+        end
+
+        # Unpublish a single service
+        def unpublish(service, ttl=@sa.ttl)
+            todo = []
+            to_update << {:target=>service.type_in_zone,
+                :type=>Dnsruby::Types.PTR,
+                :value=>service.type_in_zone_with_name}
+            to_update << {:target=>service.type_in_zone_with_name, 
+                :type=>DnsRuby::Types.SRV}
+            to_update << {:target=>service.type_in_zone_with_name,
+                :type=>Dnsruby::Types.TXT}
+            DNSUpdate.unpublish_all(todo)
+        end
+
+        # Process a single Wamupd::Action out of the queue
+        def process_action(action)
+            case action.action
+            when Wamupd::ActionType::ADD
+                begin
+                    add_service(action.record)
+                    id = publish(action.record)
+                    signal(:added, action.record, id)
+                rescue DuplicateServiceError
+                    # Do nothing
+                end
+            when Wamupd::ActionType::DELETE
+                delete_service(action.record)
+                unpublish_service(action.record)
+                signal(:deleted, action.record)
+            when Wamupd::ActionType::QUIT
+                # Flush the queue, then signal quit
+                until @queue.empty?
+                    process_action(@queue.pop(false))
+                end
+                unpublish_all
+                signal(:quit)
+            end
+        end
+
+        # Exit out of the main loop
+        def exit
+            @queue << Wamupd::Action.new(Wamupd::ActionType::QUIT)
+        end
+
+        # Wait for data to go into the queue, and handle it when it does
+        def run
+            while true
+                process_action(@queue.pop)
+            end
+        end
+
+        # Takes care of updating leases. Run it in a separate thread from
+        # the main "run" function
+        def update_leases
+            while true
+                now = Time.now
+                while (not @lease_queue.empty?) and (@lease_queue.next.date < now)
+                    item = @lease_queue.pop
+                    if @services.has_key?(item.service.identifier)
+                        signal(:renewed, item.service)
+                        publish(item.service)
+                    end
+                end
+                sleep(@sa.sleep_time)
+            end
+        end
+
+        private :process_action, :publish
+    end
+end

data/lib/wamupd/dns_ip_controller.rb

@@ -0,0 +1,95 @@
+# Copyright (C) 2009-2010 James Brown <roguelazer@roguelazer.com>.
+#
+# This file is part of wamupd.
+#
+# wamupd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wamupd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with wamupd.  If not, see <http://www.gnu.org/licenses/>.
+
+require "wamupd/lease_update"
+require "wamupd/main_settings"
+
+require "algorithms"
+require "dnsruby"
+require "ipaddr"
+require "socket"
+
+# Wamupd is a module that is used to namespace all of the wamupd code.
+module Wamupd
+    # Manage IP information in DNS
+    #
+    # == Signals
+    # [:added]
+    #    A record was published. Parameters are the type (A/AAAA) and the
+    #    address
+    # [:removed]
+    #    A record was unpublished. Parameters are the type (A/AAAA) and the
+    #    address
+    class DNSIpController
+        include Wamupd::Signals
+
+        # Constructor
+        def initialize()
+            @sa = MainSettings.instance
+            @sa.get_ip_addresses
+            @resolver = @sa.resolver
+            @lease_queue = Containers::PriorityQueue.new
+        end
+
+        # Publish A and AAAA records
+        def publish
+            if (@sa.ipv4)
+                DNSUpdate.publish(@sa.target, Dnsruby::Types.A, @sa.ttl, @sa.ipv4)
+                signal(:added, Dnsruby::Types.A, @sa.ipv4)
+            end
+            if (@sa.ipv6)
+                DNSUpdate.publish(@sa.target, Dnsruby::Types.AAAA, @sa.ttl, @sa.ipv6)
+                signal(:added, Dnsruby::Types.AAAA, @sa.ipv6)
+            end
+            update_time = Time.now() + @sa.lease_time
+            @lease_queue.push(Wamupd::LeaseUpdate.new(update_time, nil), update_time)
+        end
+
+        # Synonym for publish
+        def publish_all
+            publish
+        end
+
+        # Unpublish A and AAAA records
+        def unpublish
+            if (@sa.ipv4)
+                DNSUpdate.unpublish(@sa.target, Dnsruby::Types.A, @sa.ipv4)
+                signal(:removed, Dnsruby::Types.A, @sa.ipv4)
+            end
+            if (@sa.ipv6)
+                DNSUpdate.unpublish(@sa.target, Dnsruby::Types.AAAA, @sa.ipv6)
+                signal(:removed, Dnsruby::Types.A, @sa.ipv6)
+            end
+        end
+
+        # Synonym for unpublish
+        def unpublish_all
+            unpublish
+        end
+
+        # Update leases when required. Please run in a separate thread.
+        def update_leases
+            while true
+                now = Time.now
+                while (not @lease_queue.empty?) and (@lease_queue.next.date < now)
+                    publish
+                end
+                sleep(@sa.sleep_time)
+            end
+        end
+    end
+end

data/lib/wamupd/dns_update.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/ruby
+# Copyright (C) 2009-2010 James Brown <roguelazer@roguelazer.com>.
+#
+# This file is part of wamupd.
+#
+# wamupd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wamupd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with wamupd.  If not, see <http://www.gnu.org/licenses/>.
+
+require "dnsruby"
+
+# Wamupd is a module that is used to namespace all of the wamupd code.
+module Wamupd
+    # Class to help with constructing DNS UPDATEs. Probably not useful except to
+    # me.
+    class DNSUpdate
+        @@queue = nil
+        @@outstanding = []
+
+        # Set the queue
+        def self.queue=(v)
+            @@queue=v
+        end
+
+        # How many requests are outstanding?
+        def self.outstanding
+            return @@outstanding
+        end
+
+        # Is this update going to be asynchronous?
+        def self.async?
+            return (not @@queue.nil?)
+        end
+    
+        # Publish a batch of DNS records
+        #
+        # Arguments:
+        # An array of records to publish. Each record is either a Hash
+        # containing the keys :target, :type, :ttl, and :value, or an array of
+        # items which could be args to Dnsruby::Update::add
+        def self.publish_all(args)
+            sa = MainSettings.instance()
+            resolver = sa.resolver
+            update = Dnsruby::Update.new(sa.zone, "IN")
+            shortest_ttl=86400
+            args.each { |arg|
+                if (arg.kind_of?(Hash))
+                    update.add(arg[:target], arg[:type], arg[:ttl], arg[:value])
+                    if (arg[:ttl] < shortest_ttl)
+                        shortest_ttl = arg[:ttl]
+                    end
+                elsif (arg.kind_of?(Array))
+                    if (arg[2] < shortest_ttl)
+                        shortest_ttl = arg[2]
+                    end
+                    update.add(*arg)
+                else
+                    raise ArgumentError.new("Could not parse arguments")
+                end
+            }
+            opt = Dnsruby::RR::OPT.new
+            lease_time = Dnsruby::RR::OPT::Option.new(2, [shortest_ttl].pack("N"))
+            opt.klass="IN"
+            opt.options=[lease_time]
+            opt.ttl = 0
+            update.add_additional(opt)
+            update.header.rd = false
+            queue_id = nil
+            begin
+                if (async?)
+                    queue_id = resolver.send_async(update, @@queue)
+                    @@outstanding << queue_id
+                else
+                   resolver.send_message(update)
+                   queue_id = true
+                end
+            rescue Dnsruby::TsigNotSignedResponseError => e
+                # Not really an error for UPDATE; we don't care if the reply is
+                # signed!
+                nil
+            rescue Exception => e
+                $stderr.puts "Registration failed: #{e.to_s}"
+            end
+            return queue_id
+        end
+
+        # Publish a single DNS record
+        #
+        # Arguments:
+        # Same as Dnsruby::Update::add
+        def self.publish(*args)
+            self.publish_all([args])
+        end
+
+        # Unpublish a batch of DNS records
+        #
+        # Arguments:
+        # An array of records to unpublish. Each record is either a Hash
+        # containing keys :target, :type, and :value, or an array of items which
+        # could be args to Dnsruby::Update::delete
+        def self.unpublish_all(*args)
+            sa = MainSettings.instance()
+            resolver = sa.resolver
+            update = Dnsruby::Update.new(sa.zone, "IN")
+            args.each { |arg|
+                if (arg.kind_of?(Hash))
+                    if (arg.has_key?(:value))
+                        update.delete(arg[:target], arg[:type], arg[:value])
+                    else
+                        update.delete(arg[:target], arg[:type])
+                    end
+                elsif (arg.kind_of?(Array))
+                    update.delete(*arg)
+                else
+                    raise ArgumentError.new("Could not parse arguments")
+                end
+            }
+            begin
+                if (async?)
+                    queue_id = resolver.send_async(update, @@queue)
+                    @@outstanding << queue_id
+                else
+                    resolver.send_message(update)
+                end
+            rescue Dnsruby::NXRRSet => e
+                $stderr.puts "Could not remove record because it doesn't exist!"
+            rescue Dnsruby::TsigNotSignedResponseError => e
+                # Not really an error for UPDATE; we don't care if the reply is
+                # signed!
+                nil
+            rescue Exception => e
+                $stderr.puts "Unregistration failed: #{e.to_s}"
+            end
+
+        end
+
+        # Unpublish a single DNS record
+        #
+        # Arguments:
+        # Same as Dnsruby::Update::delete
+        def self.unpublish(*args)
+            self.unpublish_all(args)
+        end
+    end
+end

data/lib/wamupd/lease_update.rb

@@ -0,0 +1,29 @@
+# Copyright (C) 2010 James Brown <roguelazer@roguelazer.com>.
+#
+# This file is part of wamupd.
+#
+# wamupd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wamupd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with wamupd.  If not, see <http://www.gnu.org/licenses/>.
+
+module Wamupd
+    # Struct for lease update records
+    class LeaseUpdate
+        attr_accessor :date
+        attr_accessor :service
+
+        def initialize(date, service)
+            @date = date
+            @service = service
+        end
+    end
+end