apt_control 0.3.2 → 0.4.0

data/lib/apt_control.rb

@@ -6,10 +6,12 @@ require 'logger'
 module AptControl
 
   require 'apt_control/exec'
-  require 'apt_control/notify'
+  require 'apt_control/jabber'
   require 'apt_control/control_file'
   require 'apt_control/apt_site'
   require 'apt_control/build_archive'
+  require 'apt_control/package_states'
+  require 'apt_control/includer'
 
   class Version
     include Comparable

data/lib/apt_control/build_archive.rb

@@ -66,9 +66,9 @@ module AptControl
     # watch the build directory, adding new packages and versions to the
     # in-memory list as it sees them.  Yields to the given block with the
     # package and the new version
-    def watch(&block)
+    def watch(fs_listener_factory, &block)
       @logger.info("Watching for new changes files in #{@dir}")
-      Listen.to(@dir, :filter => /\.changes$/) do |modified, added, removed|
+      fs_listener_factory.new(@dir, /\.changes$/) do |modified, added, removed|
         added.each do |fname|
           begin
             fname = File.basename(fname)
@@ -89,7 +89,7 @@ module AptControl
             next
           end
         end
-      end
+      end.start.join
     end
 
     class Package

data/lib/apt_control/cli.rb

@@ -39,13 +39,17 @@ module AptControl
     end
 
     module Common
+      # FIXME tidy up with some meta magic
+      def package_states ; ancestor(Root).package_states ; end
+      def includer ; ancestor(Root).includer ; end
       def apt_site ; ancestor(Root).apt_site ; end
       def control_file ; ancestor(Root).control_file ; end
       def build_archive ; ancestor(Root).build_archive ; end
-      def notifier ; ancestor(Root).notify ; end
+      def notifier ; ancestor(Root).notifier ; end
       def notify(msg) ; ancestor(Root).notify(msg) ; end
       def validate_config! ; ancestor(Root).validate_config! ; end
       def logger ; ancestor(Root).logger ; end
+      def fs_listener_factory ; ancestor(Root).fs_listener_factory ; end
 
       def each_package_state(&block)
         control_file.distributions.each do |dist|
@@ -75,6 +79,7 @@ module AptControl
       config :jabber_id, "Jabber ID for notifications", :required => false
       config :jabber_password, "Password for connecting to jabber server", :required => false
       config :jabber_chatroom_id, "Jabber ID for chatroom to send notifications to", :required => false
+      config :disable_inotify, "Set to true to disable use of inotify", :required => false
 
       description """
 Move packages from an archive in to your reprepro style apt repository.
@@ -141,6 +146,12 @@ YAML file containing a single hash of key value/pairs for each option.
         end
       end
 
+      def package_states
+        @package_states ||= PackageStates.new(apt_site: apt_site,
+          build_archive: build_archive,
+          control_file: control_file)
+      end
+
       def apt_site
         @apt_site ||= AptSite.new(config[:apt_site_dir], logger)
       end
@@ -154,14 +165,48 @@ YAML file containing a single hash of key value/pairs for each option.
       end
 
       def notifier
-        @notify ||= Notify::Jabber.new(:jid => config[:jabber_id], :logger => logger,
+        @notify ||= Jabber.new(:jid => config[:jabber_id], :logger => logger,
           :password => config[:jabber_password], :room_jid => config[:jabber_chatroom_id])
       end
 
+      def includer
+        @includer ||= Includer.new(apt_site, build_archive)
+      end
+
+      class FSListenerFactory
+
+        attr_reader :disable_inotify
+
+        def initialize(options={})
+          @disable_inotify = options[:disable_inotify]
+        end
+
+        def new(dir, pattern, &on_change)
+          Listen.to(dir).filter(pattern).tap do |listener|
+            if disable_inotify
+              listener.force_polling(true)
+              listener.polling_fallback_message(false)
+            end
+
+            listener.change(&on_change)
+          end
+        end
+      end
+
+      def fs_listener_factory
+        @fs_listener_factory ||= FSListenerFactory.new(
+          disable_inotify: config[:disable_inotify].to_s == 'true')
+      end
+
       def notify(message)
         logger.info("notify: #{message}")
-        return unless config[:jabber_enabled]
-        notifier.message(message)
+        return unless config[:jabber_enabled].to_s == 'true'
+        begin
+          notifier.send_message(message)
+        rescue => e
+          logger.error("Unable to send notification to jabber: #{e}")
+          logger.error(e)
+        end
       end
     end
   end

data/lib/apt_control/cli/include.rb

@@ -10,21 +10,12 @@ that the control file will allow"""
     def run
       validate_config!
 
-      control_file.distributions.each do |dist|
-        dist.package_rules.each do |rule|
-          included = apt_site.included_version(dist.name, rule.package_name)
-          available = build_archive[rule.package_name]
-
-          next unless available
-
-          if rule.upgradeable?(included, available)
-            version = rule.upgradeable_to(available).max
-            if options[:noop]
-              puts "I want to upgrade from #{included} to version #{version} of #{rule.package_name}"
-            else
-              apt_site.include!(dist.name, build_archive.changes_fname(rule.package_name, version))
-            end
-          end
+      includer.perform_for_all(package_states) do |state, version|
+        if options[:noop]
+          puts "#{state.dist.name} #{state.package_name} #{state.included} => #{version}"
+          false
+        else
+          true
         end
       end
     end

data/lib/apt_control/cli/status.rb

@@ -9,33 +9,29 @@ module AptControl::CLI
     def run
       validate_config!
 
-      control_file.distributions.each do |dist|
-        puts dist.name unless options[:machine_readable]
-        dist.package_rules.each do |rule|
-          included = apt_site.included_version(dist.name, rule.package_name)
-          available = build_archive[rule.package_name]
-
-          satisfied = included && rule.satisfied_by?(included)
-          upgradeable = available && rule.upgradeable?(included, available)
-
-          if options[:machine_readable]
-            fields = [
-              dist.name,
-              rule.package_name,
-              "(#{rule.restriction} #{rule.version})",
-              "#{upgradeable ? 'U' : '.'}#{satisfied ? 'S' : '.'}",
-              "included=#{included || '<none>'}",
-              "available=#{available && available.join(', ') || '<none>'} "
-            ]
-            puts fields.join(' ')
-          else
-            puts "  #{rule.package_name}"
-            puts "    rule       - #{rule.restriction} #{rule.version}"
-            puts "    included   - #{included}"
-            puts "    available  - #{available && available.join(', ')}"
-            puts "    satisfied  - #{satisfied}"
-            puts "    upgradeable - #{upgradeable}"
-          end
+      if options[:machine_readable]
+        package_states.each do |state|
+          fields = [
+            state.dist.name,
+            state.package_name,
+            "(#{state.rule.restriction} #{state.rule.version})",
+            "#{state.includeable? ? 'I' : '.'}#{state.satisfied? ? 'S' : '.'}",
+            "included=#{state.included || '<none>'}",
+            "available=#{state.available? ? state.available.join(', ') : '<none>'} "
+          ]
+          puts fields.join(' ')
+        end
+      else
+        last_dist = nil
+        package_states.each do |state|
+          puts state.dist.name if last_dist != state.dist
+          last_dist = state.dist
+          puts "  #{state.package_name}"
+          puts "    rule        - #{state.rule.restriction} #{state.rule.version}"
+          puts "    included    - #{state.included}"
+          puts "    available   - #{state.available.join(', ')}"
+          puts "    satisfied   - #{state.satisfied?}"
+          puts "    includeable - #{state.includeable?}"
         end
       end
     end

data/lib/apt_control/cli/watch.rb

@@ -55,40 +55,69 @@ has the usual set of options for running as an init.d style daemon.
     end
 
     def start_watching
+      threads = [
+        watch_control_in_new_thread,
+        watch_build_archive_in_new_thread
+      ]
+
+      notify("apt_control watcher is up, waiting for changes to control file and new packages...")
+
+      # these should never exit, so stop main thread exiting by joining to them
+      threads.each(&:join)
+    end
+
+    def watch_control_in_new_thread
       # update the all the rules if the control file changes
-      Thread.new { control_file.watch { notify "Control file reloaded" } }
-
-      notify("Watching for new packages in #{build_archive.dir}")
-      build_archive.watch do |package, new_version|
-        notify("new package: #{package.name} at #{new_version}")
-
-        updated = control_file.distributions.map do |dist|
-          rule = dist[package.name] or next
-          included = apt_site.included_version(dist.name, package.name)
-
-          if rule.upgradeable?(included, [new_version])
-            if options[:noop]
-              notify("package #{package.name} can be upgraded to #{new_version} on #{dist.name} (noop)")
-            else
-              # FIXME error handling here, please
-              begin
-                apt_site.include!(dist.name, build_archive.changes_fname(rule.package_name, new_version))
-                notify("included package #{package.name}-#{new_version} in #{dist.name}")
-              rescue => e
-                notify("Failed to include package #{package.name}-#{new_version}, check log for more details")
-                logger.error("failed to include package #{package.name}")
-                logger.error(e)
-              end
+      Thread.new do
+        begin
+          control_file.watch(fs_listener_factory) do
+            notify "Control file reloaded"
+            # FIXME need to do some kind of locking or actor style dev for this
+            # as it looks like there could be some concurrency bugs lurking
+            includer.perform_for_all(package_states) do |package_state, new_version|
+              notify("included package #{package_state.package_name}-#{new_version} in #{package_state.dist.name}")
+              true
             end
-            dist.name
-          else
-            nil
           end
-        end.compact
+        ensure
+          logger.warn("control file watch loop exited")
+        end
+      end
+    end
+
+    def watch_build_archive_in_new_thread
+      Thread.new do
+        begin
+          build_archive.watch(fs_listener_factory) do |package, new_version|
+            handle_new_package(package, new_version)
+          end
+        ensure
+          logger.warn("build archive watch loop exited")
+        end
+      end
+    end
 
-        if updated.size == 0
-          notify("package #{package.name} could not be updated on any distributions")
+    def handle_new_package(package, new_version)
+      notify("new package: #{package.name} at #{new_version}")
+
+      matched_states = package_states.select {|s| s.package_name == package.name }
+
+      updated = matched_states.map do |state|
+        if state.includeable_to.max == new_version
+          begin
+            includer.perform_for(state, new_version, options[:noop])
+            notify("included package #{package.name}-#{new_version} in #{state.dist.name}")
+            state.dist.name
+          rescue => e
+            notify("Failed to include package #{package.name}-#{new_version}, check log for more details")
+            logger.error("failed to include package #{package.name}")
+            logger.error(e)
+          end
         end
+      end.compact
+
+      if updated.size == 0
+        notify("package #{package.name} could not be updated on any distributions")
       end
     end
   end

data/lib/apt_control/control_file.rb

@@ -40,12 +40,12 @@ module AptControl
 
     # Watch the control file for changes, rebuilding
     # internal data structures when it does
-    def watch(&block)
+    def watch(fs_listener_factory, &block)
       path = File.expand_path(@path)
-      @logger.info("Watching for changes to #{path}")
       dir = File.dirname(path)
       fname = File.basename(path)
-      Listen.to(dir, :filter => /#{Regexp.quote(fname)}/) do |modified, added, removed|
+      @logger.info("Watching for changes to #{path}")
+      fs_listener_factory.new(dir, /#{Regexp.quote(fname)}/) do |modified, added, removed|
         begin
           @logger.info("Change to control file detected...")
           inifile = IniFile.load(path)
@@ -60,7 +60,7 @@ module AptControl
           @logger.error("Error reloading changes: #{e}")
           @logger.error(e)
         end
-      end
+      end.start.join
     end
 
     class PackageRule
@@ -111,14 +111,14 @@ module AptControl
 
       # will return true if a) there is a higher version available than is
       # included b) any of the available packages satisfy this rule
-      def upgradeable?(included, available)
+      def includeable?(included, available)
         return false unless higher_available?(included, available)
         higher = available.select {|a| a > included }
         return true if higher.any? {|a| satisfied_by?(a) }
       end
 
       # will return the subset of versions from available that satisfy this rule
-      def upgradeable_to(available)
+      def includeable_to(available)
         available.select {|a| satisfied_by?(a) }
       end
     end

data/lib/apt_control/includer.rb

@@ -0,0 +1,27 @@
+module AptControl
+
+  # Wraps the common functionality involved in including the latest includeable
+  # package in an apt site
+  class Includer
+    def initialize(apt_site, build_archive)
+      @apt_site = apt_site
+      @build_archive = build_archive
+    end
+
+    def perform_for_all(package_states, &visitor)
+      package_states.each do |state|
+        next unless state.includeable?
+
+        version = state.includeable_to.max
+        perform = (block_given? && yield(state, version)) || true
+
+        perform_for(state, version) if perform
+      end
+    end
+
+    def perform_for(state, version, noop=false)
+      changes_fname = @build_archive.changes_fname(state.package_name, version)
+      @apt_site.include!(state.dist.name, changes_fname) unless noop
+    end
+  end
+end

data/lib/apt_control/jabber.rb

@@ -0,0 +1,117 @@
+require 'xmpp4r/jid'
+require 'xmpp4r/client'
+require 'xmpp4r/muc'
+require 'xmpp4r/muc/helper/simplemucclient'
+
+module AptControl
+  class Jabber
+    include ::Jabber
+
+    def initialize(options)
+      @jid      = options[:jid]
+      @password = options[:password]
+      @room_jid = options[:room_jid]
+      @logger   = options[:logger]
+
+      swallow_errors { connect! } unless options[:defer_connect]
+    end
+
+    def send_message(msg)
+      if not_connected?
+        connect!
+      end
+
+      begin
+        attempt_reconnect do
+          @logger.info("sending message to chat room: #{msg}")
+          @muc.send(Message.new(nil, msg))
+        end
+      rescue JabberError => e
+        raise SendError.new("failed to send message to chat room", e)
+      end
+    end
+
+    # execute the block, swallow any Jabber::Error errors it raises, reporting
+    # them to the logger
+    def swallow_errors(jabber_errors_too=false, &block)
+      begin
+        yield(self)
+      rescue Error => e
+        @logger.error("swallowed error: #{e}")
+        @logger.error(e)
+      rescue JabberError => e
+        raise unless jabber_errors_too
+        @logger.error("swallowed error: #{e}")
+        @logger.error(e)
+      end
+    end
+
+    def connected?
+      @client && @client.is_connected? && @muc && @muc.active?
+    end
+
+    def not_connected? ; ! connected? ; end
+
+    private
+
+    def attempt_reconnect(&block)
+      begin
+        yield
+      rescue JabberError => e
+        @logger.error("swallowing jabber error: #{e}")
+        @logger.error(e)
+        @logger.error("attempting message send again...")
+        connect!
+        yield
+      end
+    end
+
+    def connect!
+      # ::Jabber::debug = true
+      begin
+        swallow_errors { @client.disconnect if @client && @client.is_connected? }
+
+        @logger.info("Jabber connecting with jid #{@jid}")
+        @client = Client.new(JID.new(@jid))
+        @client.connect
+        @client.auth(@password)
+      rescue JabberError => e
+        raise ConnectionError.new("error connecting to client", e)
+      end
+
+      begin
+        swallow_errors { @muc.exit("reconnecting") if @muc && @muc.active? }
+
+        @muc = Jabber::MUC::SimpleMUCClient.new(@client)
+        @muc.join(JID.new(@room_jid))
+        @logger.info("joined room #{@room_jid}")
+      rescue JabberError => e
+        raise ConnectionError.new("error joining room", e)
+      end
+    end
+
+    # Thank you to http://rubyforge.org/projects/nestegg for the pattern
+    class Error < StandardError
+
+      attr_reader :cause
+      alias :wrapped_error :cause
+
+      def initialize(msg, cause=nil)
+        @cause = cause
+        super(msg)
+      end
+
+      def set_backtrace(bt)
+        if cause
+          bt << "cause: #{cause.class.name}: #{cause}"
+          bt.concat cause.backtrace
+        end
+        super(bt)
+      end
+
+    end
+
+    class ConnectionError < Error ; end
+    class SendError < Error ; end
+  end
+end

data/lib/apt_control/package_states.rb

@@ -0,0 +1,59 @@
+module AptControl
+  class PackageStates
+    include Enumerable
+
+    def initialize(options)
+      @apt_site      = options.fetch(:apt_site)
+      @build_archive = options.fetch(:build_archive)
+      @control_file  = options.fetch(:control_file)
+    end
+
+    # yield a package state for each entry in the control file
+    def each(&block)
+      @control_file.distributions.each do |dist|
+        dist.package_rules.each do |rule|
+          yield PackageState.new(dist: dist, rule: rule, apt_site: @apt_site,
+            build_archive: @build_archive)
+        end
+      end
+    end
+  end
+
+  # Brings together the state of a particular package in a particular
+  # distribution
+  class PackageState
+
+    attr_reader :dist, :rule
+
+    def initialize(options)
+      @dist          = options.fetch(:dist)
+      @rule          = options.fetch(:rule)
+      @apt_site      = options.fetch(:apt_site)
+      @build_archive = options.fetch(:build_archive)
+    end
+
+    def included
+      @included ||= @apt_site.included_version(dist.name, rule.package_name)
+    end
+
+    def available
+      @available ||= (@build_archive[rule.package_name] || [])
+    end
+
+    def package_name ; rule.package_name ; end
+    def included? ;    !! included       ; end
+    def available? ;   available.any?    ; end
+
+    def satisfied?
+      included? && rule.satisfied_by?(included)
+    end
+
+    def includeable?
+      available? && rule.includeable?(included, available)
+    end
+
+    def includeable_to
+      rule.includeable_to(available)
+    end
+  end
+end

data/lib/apt_control/version.rb

@@ -1,3 +1,3 @@
 module AptControl
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,151 +1,159 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: apt_control
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 0.4.0
   prerelease: 
-  segments: 
-  - 0
-  - 3
-  - 2
-  version: 0.3.2
 platform: ruby
-authors: 
+authors:
 - Nick Griffiths
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-05-27 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: popen4
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: climate
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: climate
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: inifile
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: inifile
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: xmpp4r
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: xmpp4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: listen
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 0
-        - 7
-        version: "0.7"
+      - !ruby/object:Gem::Version
+        version: '1.1'
   type: :runtime
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: rb-inotify
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 25
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :runtime
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
   name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id008
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
-email: 
+email:
 - nicobrevin@gmail.com
-executables: 
+executables:
 - apt_control
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - bin/apt_control
 - lib/apt_control.rb
+- lib/apt_control/jabber.rb
+- lib/apt_control/package_states.rb
 - lib/apt_control/cli.rb
-- lib/apt_control/notify.rb
 - lib/apt_control/version.rb
+- lib/apt_control/includer.rb
 - lib/apt_control/exec.rb
 - lib/apt_control/cli/watch.rb
 - lib/apt_control/cli/include.rb
@@ -155,38 +163,26 @@ files:
 - lib/apt_control/control_file.rb
 homepage: http://github.com/playlouder/apt_control
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 23
-      segments: 
-      - 1
-      - 3
-      - 6
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Automatically manage an apt repository that changes a lot
 test_files: []
-

data/lib/apt_control/notify.rb

@@ -1,37 +0,0 @@
-require 'stringio'
-require 'xmpp4r/jid'
-require 'xmpp4r/client'
-require 'xmpp4r/muc'
-require 'xmpp4r/muc/helper/simplemucclient'
-
-module AptControl::Notify
-
-  class Jabber
-    include ::Jabber
-
-    def initialize(options={})
-      @jid      = options[:jid]
-      @password = options[:password]
-      @room_jid = options[:room_jid]
-      @logger   = options[:logger]
-
-      connect!
-    end
-
-    def connect!
-      # ::Jabber::debug = true
-      @logger.info("Jabber connecting with jid #{@jid}")
-      @client = Client.new(JID.new(@jid))
-      @client.connect
-      @client.auth(@password)
-
-      @muc = Jabber::MUC::SimpleMUCClient.new(@client)
-      @muc.join(JID.new(@room_jid))
-      @logger.info("joined room #{@room_jid}")
-    end
-
-    def message(msg)
-      @muc.send(Message.new(nil, msg))
-    end
-  end
-end