apt_control 0.3.0

data/bin/apt_control

@@ -0,0 +1,5 @@
+#! /usr/bin/env ruby
+
+require 'apt_control'
+require 'apt_control/cli'
+AptControl::CLI.main

data/lib/apt_control.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+require 'inifile'
+require 'listen'
+require 'logger'
+
+module AptControl
+
+  require 'apt_control/exec'
+  require 'apt_control/notify'
+  require 'apt_control/control_file'
+  require 'apt_control/apt_site'
+  require 'apt_control/build_archive'
+
+  class Version
+    include Comparable
+
+    attr_reader :major, :minor, :bugfix, :debian
+
+    def self.parse(string)
+      match = /([0-9]+)(?:\.([0-9]+))?(?:\.([0-9]+))?(?:-(.+))?/.match(string)
+      match && new(*(1..4).map { |i| match[i] }) or raise "could not parse #{string}"
+    end
+
+    def initialize(major, minor, bugfix, debian)
+      @major = major && major.to_i
+      @minor = minor && minor.to_i
+      @bugfix = bugfix && bugfix.to_i
+      @debian = debian
+    end
+
+    def to_a
+      [@major, @minor, @bugfix, @debian]
+    end
+
+    def <=>(rhs)
+      self.to_a.compact <=> rhs.to_a.compact
+    end
+
+    def ==(rhs)
+      self.to_a == rhs.to_a
+    end
+
+    def =~(rhs)
+      self.to_a[0...3] == rhs.to_a[0...3]
+    end
+
+    # = operator
+    # returns true if this version satisfies the given rule and version spec,
+    # where all parts of the version given match our parts.  Not commutative,
+    # as  1.3.1.4 satisfies 1.3, but 1.3 does not satisfy 1.3.1.4
+    def satisfies_exactly(rhs)
+      rhs.to_a.compact.zip(self.to_a).each do |rhs_part, lhs_part|
+        return false unless rhs_part == lhs_part
+      end
+      return true
+    end
+
+    # >= operator
+    # returns true if this version is greater than or equal to the given version
+    def satisfies_loosely(rhs)
+      return true if satisfies_exactly(rhs)
+      return true if (self.to_a.compact <=> rhs.to_a.compact) >= 0
+      return false
+    end
+
+    # ~> operator
+    def satisfies_pessimisticly(rhs)
+
+      return false unless self.to_a[0...2] == rhs.to_a[0...2]
+
+      lhs_half = self.to_a[2..-1]
+      rhs_half = rhs.to_a[2..-1]
+
+      (lhs_half.compact <=> rhs_half.compact) >= 0
+    end
+
+    def to_s
+      [
+        "#{major}.#{minor}",
+        bugfix && ".#{bugfix}",
+        debian && "-#{debian}"
+      ].compact.join
+    end
+  end
+end

data/lib/apt_control/apt_site.rb

@@ -0,0 +1,31 @@
+module AptControl
+  # represents the reprepro apt site that we query and include packages in to
+  class AptSite
+    include Exec::Helpers
+
+    def initialize(apt_site_dir, logger)
+      @apt_site_dir = apt_site_dir
+      @logger = logger
+    end
+
+    def reprepro_cmd
+      "reprepro -b #{@apt_site_dir}"
+    end
+
+    # query the apt site for which version of a package is installed for a
+    # particular distribution
+    def included_version(distribution_name, package_name)
+      command = "#{reprepro_cmd} -Tdsc list #{distribution_name} #{package_name}"
+      output = exec(command, :name => 'reprepro')
+      version_string = output.split(' ').last
+      version_string && Version.parse(version_string)
+    end
+
+    # include a particular version in to a distribution.  Will likely fail for a
+    # myriad number of reasons, so spits out error messages to sdterr
+    def include!(distribution_name, changes_fname)
+      command = "#{reprepro_cmd} --ignore=wrongdistribution include #{distribution_name} #{changes_fname}"
+      exec(command, :name => 'reprepro')
+    end
+  end
+end

data/lib/apt_control/build_archive.rb

@@ -0,0 +1,116 @@
+module AptControl
+
+  # represents a directory containing output from lots of dpkg builds
+  class BuildArchive
+
+    attr_reader :packages
+    attr_reader :dir
+
+    def initialize(dir, logger)
+      @dir = File.expand_path(dir)
+      @logger = logger
+      parse!
+    end
+
+    # get a list of all versions for a particular package
+    def [](name)
+      package = packages.find {|p| p.name == name }
+      package && package.versions
+    end
+
+    # return absolute path to a changes file for a particular package and version
+    def changes_fname(package_name, version)
+      fname = Dir.chdir(@dir) do
+        parsed_changes = Dir["#{package_name}_#{version}_*.changes"].find { |fname|
+          parse_changes_fname(fname)
+        }
+      end
+
+      fname && File.expand_path(File.join(@dir, fname))
+    end
+
+    def parse!
+      Dir.chdir(@dir) do
+        parsed_changes = Dir['*.changes'].map { |fname|
+          begin
+            parse_changes_fname(fname)
+          rescue => e
+            @logger.error("Unable to parse changes filename: #{fname}")
+            @logger.error(e)
+          end
+        }.compact
+
+        package_names = parsed_changes.map(&:first).sort.uniq
+        @packages = package_names.map do |name|
+          versions = parsed_changes.select {|n, v | name == n }.
+            map(&:last).
+            map {|s|
+            begin
+              Version.parse(s)
+            rescue => e
+              @logger.error("Couldn't parse version string: #{s}")
+              @logger.error(e)
+            end
+          }.compact
+          Package.new(name, versions)
+        end
+      end
+    end
+
+    def parse_changes_fname(fname)
+      name, version = fname.split('_')[0...2]
+      raise "bad changes filename #{fname}" unless name and version
+      [name, version]
+    end
+
+    # 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)
+      @logger.info("Watching for new changes files in #{@dir}")
+      Listen.to(@dir, :filter => /\.changes$/) do |modified, added, removed|
+        added.each do |fname|
+          begin
+            fname = File.basename(fname)
+            name, version_string = parse_changes_fname(fname)
+            version = Version.parse(version_string)
+
+            package = @packages.find {|p| p.name == name }
+            if package.nil?
+              @packages << package = Package.new(name, [version])
+            else
+              package.add_version(version)
+            end
+
+            yield(package, version)
+          rescue => e
+            @logger.error("Could not parse changes filename #{fname}: #{e}")
+            @logger.error(e)
+            next
+          end
+        end
+      end
+    end
+
+    class Package
+
+      attr_reader :name
+
+      def initialize(name, versions)
+        @name = name
+        @versions = versions
+      end
+
+      def add_version(version)
+        @versions << version
+      end
+
+      def versions
+        @versions.sort
+      end
+
+      def changes_fname(version) ; end
+
+    end
+  end
+end

data/lib/apt_control/cli.rb

@@ -0,0 +1,169 @@
+require 'climate'
+require 'yaml'
+
+module AptControl
+
+  # Some class methods for defining config keys
+  module ConfigDSL
+
+    def config(key, description, options={})
+      options = {:required => true}.merge(options)
+      configs << [key, description, options]
+    end
+
+    def configs
+      @configs ||= []
+    end
+  end
+
+  module CLI
+
+    def self.main
+      init_commands
+
+      Climate.with_standard_exception_handling do
+        begin
+          Root.run(ARGV)
+        rescue Exec::UnexpectedExitStatus => e
+          $stderr.puts("Error executing: #{e.command}")
+          $stderr.puts(e.stderr)
+          exit 1
+        end
+      end
+    end
+
+    def self.init_commands
+      require 'apt_control/cli/status'
+      require 'apt_control/cli/watch'
+      require 'apt_control/cli/include'
+    end
+
+    module Common
+      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 notify(msg) ; ancestor(Root).notify(msg) ; end
+      def validate_config! ; ancestor(Root).validate_config! ; end
+      def logger ; ancestor(Root).logger ; end
+
+      def each_package_state(&block)
+        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]
+
+            yield(dist, rule, included, available)
+          end
+        end
+      end
+    end
+
+    class Root < Climate::Command('apt_control')
+
+      class << self
+        include ConfigDSL
+      end
+
+      DEFAULT_CONFIG_FILE_LOCATION = '/etc/apt_control/config.yaml'
+
+      config :log_file, "File to send log output to, defaults to stdout", :required => false
+      config :apt_site_dir, "Directory containing apt files"
+      config :control_file, "Path to control file containing inclusion rules"
+      config :build_archive_dir, "Directory containing debian build files"
+      config :jabber_enabled, "Enable jabber integration", :required => false
+      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
+
+      description """
+Move packages from an archive in to your reprepro style apt repository.
+
+CONFIG
+
+All configuration can be set by passing an option on the command line, but you can
+avoid having to pass these each time by using a config file.  By default,
+apt_control looks for #{DEFAULT_CONFIG_FILE_LOCATION}, which is expected to be a
+YAML file containing a single hash of key value/pairs for each option.
+
+#{configs.map {|k, d| "#{k}: #{d}" }.join("\n\n") }
+"""
+
+      opt :config_file, "Alternative location for config file",
+        :type => :string, :short => 'f'
+
+      opt :config_option, "Supply a config option on the command line", :multi => true,
+        :type => :string, :short => 'o'
+
+      def config
+        @config ||= build_config
+      end
+
+      #
+      # Read yaml file if one exists, then apply overrides from the command line
+      #
+      def build_config
+        file = [options[:config_file], DEFAULT_CONFIG_FILE_LOCATION].
+          compact.find {|f| File.exists?(f) }
+
+        hash =
+          if file
+            YAML.load_file(file).each do |key, value|
+            stderr.puts("Warn: Unknown key in config file: #{key}") unless
+              self.class.configs.find {|opt| opt.first.to_s == key.to_s }
+          end
+          else
+            {}
+          end
+
+        options[:config_option].map {|str| str.split('=') }.
+          inject(hash) {|m, (k,v)| m.merge(k.to_sym => v) }
+      end
+
+      def validate_config!
+        self.class.configs.each do |key, desc, options|
+          if options[:required]
+            config[key] or raise Climate::ExitException, "Error: No config supplied for #{key}"
+          end
+        end
+
+        if config[:jabber_enabled]
+          self.class.configs.each do |key, desc, options|
+            next unless key.to_s['jabber_']
+            config[key] or raise Climate::ExitException, "Error: you must supply all jabber options if jabber is enabled"
+          end
+        end
+      end
+
+      def logger
+        @logger ||= Logger.new(config[:log_file] || STDOUT).tap do |logger|
+          logger.level = Logger::DEBUG
+        end
+      end
+
+      def apt_site
+        @apt_site ||= AptSite.new(config[:apt_site_dir], logger)
+      end
+
+      def control_file
+        @control_file ||= ControlFile.new(config[:control_file], logger)
+      end
+
+      def build_archive
+        @build_archive ||= BuildArchive.new(config[:build_archive_dir], logger)
+      end
+
+      def notifier
+        @notify ||= Notify::Jabber.new(:jid => config[:jabber_id], :logger => logger,
+          :password => config[:jabber_password], :room_jid => config[:jabber_chatroom_id])
+      end
+
+      def notify(message)
+        logger.info("notify: #{message}")
+        return unless config[:jabber_enabled]
+        notifier.message(message)
+      end
+    end
+  end
+end
+

data/lib/apt_control/cli/include.rb

@@ -0,0 +1,33 @@
+module AptControl::CLI
+  class Include < Climate::Command('include')
+    include Common
+    subcommand_of Root
+    description """Include in the apt site all packages from the build-archive
+that the control file will allow"""
+
+    opt :noop, "Do a dry run, printing what you would do out to stdout", :default => false
+
+    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
+        end
+      end
+    end
+  end
+end
+

data/lib/apt_control/cli/status.rb

@@ -0,0 +1,43 @@
+module AptControl::CLI
+  class Status < Climate::Command('status')
+    include Common
+    subcommand_of Root
+    description "Dump current state of apt site and build archive"
+
+    opt :machine_readable, "If true, output in a unix-friendly format", :default => false
+
+    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 - #{upgreadable}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apt_control/cli/watch.rb

@@ -0,0 +1,95 @@
+module AptControl::CLI
+  class Watch < Climate::Command('watch')
+    include Common
+    subcommand_of Root
+    description """Watch the build archive for new files to include
+
+DAEMON
+
+The watch command can run as a daemon, backgrounding itself after start up and
+has the usual set of options for running as an init.d style daemon.
+"""
+
+    opt :noop, "Only pretend to do stuff to the apt archive"
+    opt :daemonize, "Run watcher in the background", :default => false
+    opt :pidfile, "Pidfile when daemonized", :type => :string
+    opt :setuid, "Once daemonized, call setuid with this user id to drop privileges", :type => :integer
+
+    def run
+      validate_config!
+
+      # hit these before we daemonize so we don't just background and die
+      apt_site
+      control_file
+      build_archive
+
+      daemonize! if options[:daemonize]
+
+      start_watching
+    end
+
+
+    def daemonize!
+      pidfile = options[:pidfile]
+
+      if pidfile && File.exists?(pidfile)
+        $stderr.puts("pidfile exists, not starting")
+        exit 1
+      end
+
+      if uid = options[:setuid]
+        logger.info("setting uid to #{uid}")
+        begin
+          Process::Sys.setuid(uid)
+        rescue Errno::EPERM => e
+          raise Climate::ExitException, "Could not setuid with #{uid}"
+        end
+      end
+
+      pid = fork
+      exit 0 unless pid.nil?
+
+      File.open(pidfile, 'w') {|f| f.write(Process.pid) } if pidfile
+
+      at_exit { File.delete(pidfile) if File.exists?(pidfile) } if pidfile
+    end
+
+    def start_watching
+      # 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
+            end
+            dist.name
+          else
+            nil
+          end
+        end.compact
+
+        if updated.size == 0
+          notify("package #{package.name} could not be updated on any distributions")
+        end
+      end
+    end
+  end
+end

data/lib/apt_control/control_file.rb

@@ -0,0 +1,142 @@
+require 'thread'
+
+module AptControl
+
+  # Loads and models the contents of a control.ini file
+  # see example-control.ini in root of project for an example
+  class ControlFile
+
+    def initialize(path, logger)
+      @logger = logger
+      @watch_mutex = Mutex.new
+      @path = path
+      inifile = IniFile.load(@path)
+      @distributions = parse!(inifile)
+    end
+
+    def distributions
+      @watch_mutex.synchronize { @distributions }
+    end
+
+    def dump
+      @watch_mutex.synchronize do
+        @distributions.each do |d|
+          puts "#{d.name}"
+          d.package_rules.each do |pr|
+            puts "  #{pr.package_name} #{pr.restriction} #{pr.version}"
+          end
+        end
+      end
+    end
+
+    def parse!(inifile)
+      inifile.sections.map do |section|
+        rules = inifile[section].map do |key, value|
+          PackageRule.new(key, value)
+        end
+        Distribution.new(section, rules)
+      end
+    end
+
+    # Watch the control file for changes, rebuilding
+    # internal data structures when it does
+    def watch(&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|
+        begin
+          @logger.info("Change to control file detected...")
+          inifile = IniFile.load(path)
+          distributions = parse!(inifile)
+
+          @watch_mutex.synchronize do
+            @distributions = distributions
+          end
+          @logger.info("...rebuilt")
+          yield if block_given?
+        rescue => e
+          @logger.error("Error reloading changes: #{e}")
+          @logger.error(e)
+        end
+      end
+    end
+
+    class PackageRule
+      # name of package rule applies to
+      attr_reader :package_name
+
+      # version number for restriction comparison
+      attr_reader :version
+
+      # symbol for rule
+      attr_reader :restriction
+
+      def initialize(name, constraint)
+        @package_name = name
+        version = nil
+        constraint.split(" ").tap do |split|
+          @restriction, version = if split.size == 1
+                                     ['=', split.first]
+                                   else
+                                     split
+                                   end
+        end
+
+        ['=', '>=', '~>'].include?(@restriction) or
+          raise "unrecognised restriction: '#{@restriction}'"
+
+        @version = Version.parse(version)
+      end
+
+      # will return true if their is a version in available that is higher
+      # than included
+      def higher_available?(included, available)
+        available.find {|a| a > included }
+      end
+
+      # will return true if included satisfies this rule
+      def satisfied_by?(included)
+        case @restriction
+        when '='
+          included.satisfies_exactly(version)
+        when '>='
+          included.satisfies_loosely(version)
+        when '~>'
+          included.satisfies_pessimisticly(version)
+        else raise "this shouldn't have happened"
+        end
+      end
+
+      # 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)
+        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)
+        available.select {|a| satisfied_by?(a) }
+      end
+    end
+
+    # represents a set of rules mapped to a particular distribution, i.e.
+    # squeeze is a distribution
+    class Distribution
+      def initialize(name, rules)
+        @name = name
+        @package_rules = rules
+      end
+      attr_reader :name
+      attr_reader :package_rules
+
+      # find a PackageRule by package name
+      def [](package_name)
+        package_rules.find {|rule| rule.package_name == package_name }
+      end
+    end
+  end
+end

data/lib/apt_control/exec.rb

@@ -0,0 +1,121 @@
+require 'thread'
+require 'popen4'
+
+module AptControl
+  # ripped from vershunt
+  class Exec
+
+    class UnexpectedExitStatus < StandardError
+      def initialize(expected, actual, cmd, output, stdout, stderr)
+        @expected = expected
+        @actual = actual
+        @command = cmd
+        @stdout = stdout
+        @stderr = stderr
+        super("command '#{command}' exited with #{actual}, expected #{expected}")
+      end
+
+      attr_reader :expect, :actual, :command, :output, :stdout, :stderr
+      # this marries up with what popen et al return
+      alias :exitstatus :actual
+    end
+
+    module Helpers
+      def exec(command, options={})
+        # use the options we were constructed with if they exist
+        if respond_to?(:options)
+          options[:quiet] = !self.options.verbose? unless options.has_key? :quiet
+        end
+
+        if respond_to? :exec_name
+          options[:name] = exec_name unless options.has_key? :name
+        end
+
+        AptControl::Exec.exec(command, options)
+      end
+    end
+
+    def self.exec(command, options={})
+      new(options).exec(command, options)
+    end
+
+    attr_reader :name
+    attr_reader :quiet
+    alias :quiet? :quiet
+
+    def initialize(options={})
+      @name   = options.fetch(:name,   nil)
+      @quiet  = options.fetch(:quiet,  true)
+      @output = options.fetch(:output, $stdout)
+    end
+
+    def last_stdout
+      @last_stdout
+    end
+
+    def last_stderr
+      @last_stderr
+    end
+
+    def last_output
+      @last_output
+    end
+
+    def last_exitstatus
+      @last_exitstatus
+    end
+
+    def exec(command, options={})
+
+      expected = to_expected_array(options.fetch(:status, 0))
+
+      @last_stdout = ""
+      @last_stderr = ""
+      @last_output = ""
+
+      output_semaphore = Mutex.new
+
+      start = name.nil? ? '' : "#{name}: "
+
+      status = POpen4::popen4(command) do |stdout, stderr, stdin, pid|
+        t1 = Thread.new do
+          stdout.each_line do |line|
+            @last_stdout += line
+            output_semaphore.synchronize { @last_output += line }
+            @output.puts("#{start}#{line}") unless quiet?
+          end
+        end
+
+        t2 = Thread.new do
+          stderr.each_line do |line|
+            @last_stderr += line
+            output_semaphore.synchronize { @last_output += line }
+            @output.puts("#{start}#{line}") unless quiet?
+          end
+        end
+
+        t1.join
+        t2.join
+      end
+
+      @last_exitstatus = status.exitstatus
+
+      unless expected.nil? || expected.include?(status.exitstatus)
+        raise UnexpectedExitStatus.new(expected, status.exitstatus, command, @last_output, @last_stdout, @last_stderr)
+      end
+
+      @last_stdout
+    end
+
+    private
+
+    def to_expected_array(value)
+      case value
+      when :any   then nil
+      when Array  then value
+      when Numeric then [value]
+      else raise ArgumentError, "#{value} is not an acceptable exit status"
+      end
+    end
+  end
+end

data/lib/apt_control/notify.rb

@@ -0,0 +1,37 @@
+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

data/lib/apt_control/version.rb

@@ -0,0 +1,3 @@
+module AptControl
+  VERSION = '0.3.0'
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification 
+name: apt_control
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Nick Griffiths
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-28 00:00:00 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"
+  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"
+  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"
+  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"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: listen
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  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
+description: 
+email: 
+- nicobrevin@gmail.com
+executables: 
+- apt_control
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/apt_control
+- lib/apt_control.rb
+- lib/apt_control/cli.rb
+- lib/apt_control/notify.rb
+- lib/apt_control/version.rb
+- lib/apt_control/exec.rb
+- lib/apt_control/cli/watch.rb
+- lib/apt_control/cli/include.rb
+- lib/apt_control/cli/status.rb
+- lib/apt_control/build_archive.rb
+- lib/apt_control/apt_site.rb
+- lib/apt_control/control_file.rb
+homepage: http://github.com/playlouder/apt_control
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      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: []
+