repomate 0.1.0

data/bin/repomate

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+# expand path if in development mode
+if File.exists?(File.join(File.join(File.dirname(__FILE__), '..', '.git')))
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+end
+
+require 'repomate'
+require 'rubygems'
+require 'slop'
+
+options = Slop.parse do
+  banner "RepoMate (A simple debian repository management tool)
+
+  Usage: #{$0} add -s squeeze [-c main] <package>
+         #{$0} publish
+         #{$0} listpackages -r production
+
+  Actions:
+    add                - Add a package to the staging area
+    publish            - Move packages from staging area to production
+    save               - Save a checkpoint
+    load               - Load a checkpoint
+    listpackages       - List packages
+    setup              - Setup the pool
+
+  Options:"
+  on :s, :suitename=, "Set the name of the suite (lenny/squeeze...)", :argument => true
+  on :c, :component=, "Set the name of the component (main/contrib...)", :default => "main"
+  on :a, :architecture=, "Set the name of the component (main/contrib...)", :argument => true
+  on :r, :repodir, "Type of pool/category (stage/pool/production)", :argument => true
+  on :force, "Force action", :default => false
+  on :h, :help, 'Print this help message', :tail => true do
+    puts help
+    exit
+  end
+end
+
+cli = RepoMate::Cli.new
+
+if ARGV.include?("add")
+  filename = nil
+  ARGV.each do |arg|
+    if arg =~ /\.deb/
+      filename = arg
+    end
+  end
+  if filename && File.exists?(filename)
+    cli.stage(options, filename)
+  else
+    STDERR.puts "File does not exist"
+  end
+elsif ARGV.include?("publish")
+  cli.publish(options)
+elsif ARGV.include?("save")
+  cli.save_checkpoint
+elsif ARGV.include?("load")
+  cli.choose_checkpoint
+elsif ARGV.include?("listpackages")
+  cli.list_packagelist(options)
+elsif ARGV.include?("setup")
+  cli.setup(options)
+else
+  puts options.help
+end

data/etc/config.yml

@@ -0,0 +1,18 @@
+---
+:rootdir: /var/lib/repomate/repository
+:logdir: /var/log/repomate
+:dpkg: /usr/bin/dpkg
+:suites:
+    - lenny
+    - squeeze
+:components:
+    - main
+    - contrib
+:architectures:
+    - all
+    - amd64
+:origin: Repository
+:label: Repository
+:gpg_enable: yes
+:gpg_email: someone@example.net
+:gpg_password: secret

data/lib/repomate/architecture.rb

@@ -0,0 +1,105 @@
+# RepoMate module
+module RepoMate
+
+  # Class for the architecture layer of the directory structure
+  class Architecture
+
+    # Init
+    def initialize(architecture, component, suitename, category)
+      @architecture = architecture
+      @component    = component
+      @suitename    = suitename
+      @category     = category
+    end
+
+    # Returns the given architecture name (eg. all, amd64)
+    def name
+      @architecture
+    end
+
+    # Returns the directory strcuture of the architecture including all lower layers
+    def directory
+      File.join(Cfg.rootdir, @category, @suitename, @component, "binary-#{name}")
+    end
+
+    # Checks if the architecture directory exists
+    def exist?
+      Dir.exist?(directory)
+    end
+
+    # Checks if the architecture is allowed (See: configurationfile)
+    def is_allowed?
+      self.allowed.include?(@architecture)
+    end
+
+    # Checks if directory is unused
+    def is_unused?(dir)
+      status  = true
+
+      path = Dir.glob(File.join(dir, "*"))
+      path.each do |dirorfile|
+        status = false if File.directory?(dirorfile)
+        status = false if File.basename(dirorfile) =~ /\.deb$/
+      end
+
+      status
+    end
+
+    # Creates the directory strcuture of the architecture including all lower layers
+    def create
+      FileUtils.mkdir_p(directory) unless exist?
+    end
+
+    # Deletes the architecture directory including all lower layers
+    def destroy
+      FileUtils.rm_r(directory) if exist?
+    end
+
+    # Returns a list of all debian files in the architecture directory
+    def files
+      Dir.glob(File.join(directory, "*.deb"))
+    end
+
+    # Returns a dataset including the name of the architecture and the fullpath recursive through all lower layers
+    def self.dataset(category=nil)
+      data   = []
+      self.all.each do |entry|
+        parts = entry.split(/\//)
+        unless parts.length < 4
+          next unless parts[0].eql?(category) || category.eql?("all")
+          architecture = parts[3].split(/-/)
+          data << {
+            :category         => parts[0],
+            :suitename        => parts[1],
+            :component        => parts[2],
+            :architecture_dir => parts[3],
+            :architecture     => architecture[1],
+            :fullpath         => File.join(Cfg.rootdir, entry)
+          }
+        end
+      end
+      data
+    end
+
+    # Returns all directories without @rootdir
+    def self.all
+      components  = Component.all
+      dirs        = []
+      rootdir     = Cfg.rootdir
+      components.each do |component|
+        architectures = Dir.glob(File.join(rootdir, component, "*"))
+        architectures.each do |architecture|
+          dirs.push architecture.gsub(/#{rootdir}\//, '') if File.directory? architecture
+        end
+      end
+      return dirs
+    end
+
+    # Gets all configured architectures
+    def self.allowed
+      Cfg.architectures.uniq
+    end
+
+  end
+end
+

data/lib/repomate/base.rb

@@ -0,0 +1,335 @@
+require 'repomate'
+require 'date'
+require 'time'
+require 'colors'
+
+# RepoMate module
+module RepoMate
+
+  # Class containing the main logic
+  class Base
+
+    # Init
+    def initialize
+      FileUtils.mkdir_p(Cfg.rootdir)
+
+      @repository = Repository.new
+      @metafile   = Metafile.new
+      @cpdbfile   = File.join(Cfg.rootdir, "checkpoints.db")
+      @cpdb       = Database.new(@cpdbfile)
+
+      unless Dir.exists?(Cfg.logdir)
+        puts
+        puts "\tPlease run \"repomate setup\" first!".hl(:red)
+        puts
+      end
+
+      create_checkpoints_table
+
+    end
+
+    # Add's a package to the staging area
+    def stage(workload)
+      workload.each do |entry|
+        @repository.create(entry[:suitename], entry[:component])
+
+        package     = Package.new(entry[:package_fullname], entry[:suitename], entry[:component])
+        destination = Component.new(entry[:component], entry[:suitename], "stage")
+
+        FileUtils.copy(entry[:package_fullname], File.join(destination.directory, package.newbasename))
+      end
+    end
+
+    # Returns a list of staged packages for cli confirmation packed as array of hashes
+    def prepare_publish
+      workload = []
+
+      source_category      = "stage"
+      destination_category = "pool"
+
+      Component.dataset(source_category).each do |entry|
+        source = Component.new(entry[:component], entry[:suitename], source_category)
+        source.files.each do |fullname|
+          package     = Package.new(fullname, entry[:suitename], entry[:component])
+          destination = Architecture.new(package.architecture, entry[:component], entry[:suitename], destination_category)
+
+          workload << {
+            :source_fullname      => fullname,
+            :destination_fullname => File.join(destination.directory, package.newbasename),
+            :component            => entry[:component],
+            :suitename            => entry[:suitename],
+            :architecture         => package.architecture
+          }
+        end
+      end
+      workload
+    end
+
+    # Publish all staged packages. Packages will be moved from stage to pool and linked to dists
+    def publish(workload)
+      newworkload = []
+      workload.each do |entry|
+        destination = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], "dists")
+        basename    = File.basename(entry[:source_fullname])
+
+        @repository.create(entry[:suitename], entry[:component], entry[:architecture])
+
+        newworkload << {
+          :source_fullname => entry[:destination_fullname],
+          :destination_dir => destination.directory,
+          :component       => entry[:component],
+          :suitename       => entry[:suitename],
+          :architecture    => entry[:architecture]
+        }
+        FileUtils.move(entry[:source_fullname], entry[:destination_fullname])
+      end
+      workload = newworkload
+
+      save_checkpoint
+      check_versions(workload)
+    end
+
+    # Does the link job after checking versions through dpkg
+    def check_versions(workload)
+      dpkg = Cfg.dpkg
+
+      raise "dpkg is not installed" unless File.exists?(dpkg)
+
+      link_workload   = []
+      unlink_workload = []
+
+      workload.each do |entry|
+        source_package       = Package.new(entry[:source_fullname], entry[:suitename], entry[:component])
+        destination_fullname = File.join(entry[:destination_dir], source_package.newbasename)
+
+        Dir.glob("#{entry[:destination_dir]}/#{source_package.name}*.deb") do |target_fullname|
+          target_package = Package.new(target_fullname, entry[:suitename], entry[:component] )
+
+          if system("#{dpkg} --compare-versions #{source_package.version} gt #{target_package.version}")
+            puts "Package: #{target_package.newbasename} will be replaced with #{source_package.newbasename}"
+            unlink_workload << {
+              :destination_fullname => target_fullname,
+              :newbasename          => target_package.newbasename
+            }
+          elsif system("#{dpkg} --compare-versions #{source_package.version} eq #{target_package.version}")
+            puts "Package: #{source_package.newbasename} already exists with same version"
+            return
+          elsif system("#{dpkg} --compare-versions #{source_package.version} lt #{target_package.version}")
+            puts "Package: #{source_package.newbasename} already exists with higher version"
+            return
+          end
+        end
+
+        link_workload << {
+          :source_fullname      => source_package.fullname,
+          :destination_fullname => destination_fullname,
+          :suitename            => source_package.suitename,
+          :component            => source_package.component,
+          :newbasename          => source_package.newbasename
+        }
+      end
+
+      unlink(unlink_workload)
+      link(link_workload)
+    end
+
+    # links the workload
+    def link(workload)
+      action = false
+
+      workload.each do |entry|
+        @repository.create(entry[:suitename], entry[:component], entry[:architecture])
+        unless File.exists?(entry[:destination_fullname])
+          package = Package.new(entry[:source_fullname], entry[:suitename], entry[:component])
+          package.create_checksums
+
+          File.symlink(entry[:source_fullname], entry[:destination_fullname])
+          puts "Package: #{package.newbasename} linked to production => #{entry[:suitename]}/#{entry[:component]}"
+          action = true
+        end
+      end
+
+      if action
+        @metafile.create
+      end
+    end
+
+    # unlinks workload
+    def unlink(workload)
+      action = false
+
+      workload.each do |entry|
+        package = Package.new(entry[:destination_fullname], entry[:suitename], entry[:component])
+        package.delete_checksums
+
+        File.unlink(entry[:destination_fullname])
+        puts "Package: #{package.newbasename} unlinked"
+        action = true
+      end
+
+      if action
+        cleandirs
+        @metafile.create
+      end
+    end
+
+    # Create the checkpoint table
+    def create_checkpoints_table
+      sql = "create table if not exists checkpoints (
+              date varchar(25),
+              suitename varchar(10),
+              component varchar(10),
+              architecture varchar(10),
+              basename varchar(70)
+      )"
+      @cpdb.query(sql)
+    end
+
+    # Saves a checkpoint
+    def save_checkpoint
+      datetime        = DateTime.now
+      source_category = "dists"
+
+      Architecture.dataset(source_category).each do |entry|
+        source = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category)
+        source.files.each do |fullname|
+          basename = File.basename(fullname)
+          @cpdb.query("insert into checkpoints values ( '#{datetime}', '#{entry[:suitename]}', '#{entry[:component]}', '#{entry[:architecture]}', '#{basename}' )")
+        end
+      end
+
+      puts "Checkpoint (#{datetime.strftime("%F %T")}) saved"
+    end
+
+    # Loads a checkpoint
+    def load_checkpoint(number)
+      list            = get_checkpoints
+      link_workload   = []
+      unlink_workload = []
+      source_category = "dists"
+
+      Architecture.dataset(source_category).each do |entry|
+        destination = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category)
+        destination.files.each do |fullname|
+          unlink_workload << {
+            :destination_fullname => fullname,
+            :component            => entry[:component],
+            :suitename            => entry[:suitename],
+            :architecture         => entry[:architecture]
+          }
+        end
+      end
+
+      @cpdb.query("select date, suitename, component, architecture, basename from checkpoints").each do |row|
+        if row[0] == list[number]
+            suitename    = row[1]
+            component    = row[2]
+            architecture = row[3]
+            basename     = row[4]
+            source       = Architecture.new(architecture, component, suitename, "pool")
+            destination  = Architecture.new(architecture, component, suitename, "dists")
+
+            link_workload << {
+              :source_fullname      => File.join(source.directory, basename),
+              :destination_fullname => File.join(destination.directory, basename),
+              :component            => component,
+              :suitename            => suitename,
+              :architecture         => architecture
+            }
+        end
+      end
+
+      unlink(unlink_workload)
+      link(link_workload)
+    end
+
+    # Returns a list of checkpoints for the cli
+    def get_checkpoints
+      order = 0
+      dates = []
+      list  = {}
+
+      @cpdb.query("select date from checkpoints group by date order by date asc").each do |row|
+        dates << row.first
+      end
+
+      dates.each do |date|
+        order += 1
+        list[order] = date
+      end
+
+      list
+    end
+
+    # Returns a list of packages
+    def get_packagelist(category)
+      packages = []
+      if category.eql?("stage")
+        Component.dataset(category).each do |entry|
+          source = Component.new(entry[:component], entry[:suitename], category)
+          source.files.each do |fullname|
+            package = Package.new(fullname, entry[:suitename], entry[:component])
+
+            packages << {
+              :fullname    => fullname,
+              :controlfile => package.controlfile,
+              :component   => entry[:component],
+              :suitename   => entry[:suitename]
+            }
+          end
+        end
+      else
+        Architecture.dataset(category).each do |entry|
+          source = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], category)
+          source.files.each do |fullname|
+            package = Package.new(fullname, entry[:suitename], entry[:component])
+
+            packages << {
+              :fullname     => fullname,
+              :controlfile  => package.controlfile,
+              :component    => entry[:component],
+              :suitename    => entry[:suitename],
+              :architecture => entry[:architecture]
+            }
+          end
+        end
+      end
+      packages
+    end
+
+    # cleans up unused directories
+    def cleandirs
+      action = false
+
+      @repository.categories.each do |category|
+        next if category.eql?("stage")
+        Architecture.dataset(category).each do |entry|
+          directory = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], category)
+          if directory.is_unused?(entry[:fullpath])
+            action = true
+            directory.destroy
+          end
+        end
+        Component.dataset(category).each do |entry|
+          directory = Component.new(entry[:component], entry[:suitename], category)
+          if directory.is_unused?(entry[:fullpath])
+            action = true
+            directory.destroy
+          end
+        end
+        Suite.dataset(category).each do |entry|
+          directory = Suite.new(entry[:suitename], category)
+          if directory.is_unused?(entry[:fullpath])
+            action = true
+            directory.destroy
+          end
+        end
+      end
+      if action
+        puts "Cleaning structure"
+        @metafile.create
+      end
+    end
+  end
+end
+

data/lib/repomate/category.rb

@@ -0,0 +1,60 @@
+# RepoMate module
+module RepoMate
+
+  # Class for the category layer of the directory structure
+  class Category
+
+    # Init
+    def initialize(category)
+      @category = category
+    end
+
+    # Returns the name of the category (eg. pool, dists)
+    def name
+      @category
+    end
+
+    # Returns the full path of the categories directory
+    def directory
+      File.join(Cfg.rootdir, @category)
+    end
+
+    # Checks if the category directory exists
+    def exist?
+      Dir.exist?(directory)
+    end
+
+    # Creates the directory strcuture of the category
+    def create
+      FileUtils.mkdir_p(directory) unless exist?
+    end
+
+    # Deletes a categories directory
+    def destroy
+      FileUtils.rm_r(directory) if exist?
+    end
+
+    # Returns a dataset including the name of the category and the fullpath
+    def self.dataset(category=nil)
+      data   = []
+      self.all.each do |entry|
+        unless entry.nil?
+          next unless entry.eql?(category) || category.eql?("all")
+          data << {
+            :category     => entry,
+            :fullpath     => File.join(Cfg.rootdir, entry)
+          }
+        end
+      end
+      data
+    end
+
+    # Returns all directories
+    def self.all
+      dirs   = Dir.glob(File.join(Cfg.rootdir, "*"))
+      dirs.map{ |dir| File.basename(dir) unless dirs.include?(File.basename(dir)) }
+    end
+
+  end
+end
+

data/lib/repomate/cli.rb

@@ -0,0 +1,123 @@
+require 'date'
+require 'time'
+
+# RepoMate module
+module RepoMate
+
+  # Class for the commandline interface
+  class Cli
+
+    # Init
+    def initialize
+      @repomate   = Base.new
+      @repository = Repository.new
+    end
+
+    # Sets up the base directory structure by calling the repository class
+    def setup(options)
+      if options.suitename?
+        @repository.create(options[:suitename], options[:component], options[:architecture])
+      else
+        STDERR.puts "Specify a suitename with [-s|--suitname]"
+        exit 1
+      end
+    end
+
+    # Adds a given package to the staging area by calling the base class
+    def stage(options, filename)
+      if options.suitename?
+        workload = []
+        workload << {:package_fullname => filename, :suitename => options[:suitename], :component => options[:component]}
+
+        puts "Package: #{filename} moving to stage => #{options[:suitename]}/#{options[:component]}"
+
+        @repomate.stage(workload)
+      else
+        STDERR.puts "Specify a suitename with [-s|--suitname]"
+        exit 1
+      end
+    end
+
+    # Get's all packages from the staging area. Packages need to be confirmed here.
+    def publish(options)
+      @repomate.prepare_publish.each do |entry|
+        workload  = []
+        basename  = File.basename(entry[:source_fullname])
+        suitename = entry[:suitename]
+        component = entry[:component]
+
+        unless options.force?
+          printf "\n%s", "Link #{basename} to production => #{suitename}/#{component}? [y|yes|n|no]: "
+          input = STDIN.gets
+        end
+
+        if options.force? || input =~ /(y|yes)/
+          workload << {
+            :source_fullname      => entry[:source_fullname],
+            :destination_fullname => entry[:destination_fullname],
+            :component            => entry[:component],
+            :suitename            => entry[:suitename],
+            :architecture         => entry[:architecture]
+          }
+        end
+        @repomate.publish(workload) unless workload.empty?
+       end
+    end
+
+    # Save a checkpoint
+    def save_checkpoint
+      # Add verification and some output here
+      @repomate.save_checkpoint
+    end
+
+    # List all packages, see cli output
+    def list_packagelist(options)
+      if options.repodir?
+        architecture = "unknown"
+
+        packages = @repomate.get_packagelist(options[:repodir])
+        packages.each do |package|
+            architecture = package[:architecture] if package[:architecture]
+            printf "%-50s%-20s%s\n", package[:controlfile]['Package'], package[:controlfile]['Version'], "#{package[:suitename]}/#{package[:component]}/#{architecture}"
+        end
+      else
+        STDERR.puts "Specify a category with [-r|--repodir]"
+        exit 1
+      end
+    end
+
+    # Choose a checkpoint to restore.
+    def choose_checkpoint
+      list = @repomate.get_checkpoints
+
+      if list.empty?
+        STDERR.puts "We can't restore because we don't have checkpoints"
+        exit 1
+      end
+
+      puts "\n*** Restore production links to a date below. ***
+Remember: If you need to restore, the last entry might be the one you want!
+Everything between the last two \"publish (-P) commands\" will be lost if you proceed!\n\n"
+
+      list.each do |num, date|
+        datetime = DateTime.parse(date)
+        puts "#{num}) #{datetime.strftime("%F %T")}"
+      end
+
+      printf "\n%s", "Enter number or [q|quit] to abord: "
+      input  = STDIN.gets
+      number = input.to_i
+
+      if input =~ /(q|quit)/
+        puts "Aborting..."
+        exit 0
+      elsif list[number].nil?
+        STDERR.puts "Invalid number"
+        exit 1
+      else
+        @repomate.load_checkpoint(number)
+      end
+    end
+  end
+end
+