repomate 0.1.0

data/lib/repomate/component.rb

@@ -0,0 +1,102 @@
+# RepoMate module
+module RepoMate
+
+  # Class for the component layer of the directory structure
+  class Component
+
+    # Init
+    def initialize(component, suitename, category)
+      @component  = component
+      @suitename  = suitename
+      @category   = category
+    end
+
+    # Returns the given architecture name (eg. main, contrib, non-free)
+    def name
+      @component
+    end
+
+    # Returns the directory strcuture of the component including all lower layers
+    def directory
+      File.join(Cfg.rootdir, @category, @suitename, @component)
+    end
+
+    # Checks if the component directory exists
+    def exist?
+      Dir.exist?(directory)
+    end
+
+    # Checks if the component is allowed (See: configurationfile)
+    def is_allowed?
+      self.allowed.include?(@component)
+    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 component including all lower layers
+    def create
+      FileUtils.mkdir_p(directory) unless exist?
+    end
+
+    # Deletes the components directory including all lower layers
+    def destroy
+      FileUtils.rm_r(directory) if exist?
+    end
+
+    # Returns a list of all debian files in the component directory
+    def files
+      Dir.glob(File.join(directory, "*.deb"))
+    end
+
+    # Returns a dataset including the name of the component, the fullpath recursive through all lower layers
+    def self.dataset(category=nil)
+      data  = []
+      self.all.each do |entry|
+        parts = entry.split(/\//)
+        unless parts.length < 3
+          next unless parts[0].eql?(category) || category.eql?("all")
+          data << {
+            :category     => parts[0],
+            :suitename    => parts[1],
+            :component    => parts[2],
+            :fullpath     => File.join(Cfg.rootdir, entry)
+          }
+        end
+      end
+      data
+    end
+
+    # Returns all directories without @rootdir
+    def self.all
+      config  = Configuration.new
+      suites  = Suite.all
+      dirs    = []
+      rootdir = Cfg.rootdir
+      suites.each do |suite|
+        components = Dir.glob(File.join(rootdir, suite, "*"))
+        components.each do |component|
+          dirs.push component.gsub(/#{rootdir}\//, '') if File.directory? component
+        end
+      end
+      return dirs
+    end
+
+    # Gets all configured architectures
+    def self.allowed
+      Cfg.components.uniq
+    end
+
+  end
+end
+

data/lib/repomate/configuration.rb

@@ -0,0 +1,75 @@
+require 'yaml'
+
+# RepoMate module
+module RepoMate
+
+  # Configuration class
+  class Configuration
+
+    # Init
+    def initialize
+      @configfile = File.join(ENV['HOME'], '.repomate')
+
+      configure(@configfile)
+    end
+
+    # Loads configfile
+    def configure(configfile)
+      filecontent = []
+
+      filecontent = YAML::load_file(configfile) if File.exists?(configfile)
+
+      merge(filecontent)
+    end
+
+    # Merges configfile content with defaults
+    def merge(filecontent=nil)
+      config = {}
+
+      defaults = {
+        :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',
+      }
+
+      if filecontent
+        defaults.each do |key, value|
+          keysymbol = key.to_sym
+          setter = "#{key}="
+
+          if filecontent[keysymbol]
+            config[keysymbol] = filecontent[keysymbol]
+          else
+            config[keysymbol] = value
+          end
+        end
+      else
+        config = defaults
+      end
+
+      config.each do |key, value|
+        setter = "#{key}="
+
+        self.class.send(:attr_accessor, key) unless respond_to?(setter)
+
+        send setter, value
+      end
+    end
+  end
+
+  # Returns
+  Cfg = Configuration.new
+
+end
+
+
+
+

data/lib/repomate/database.rb

@@ -0,0 +1,30 @@
+require 'sqlite3'
+
+# RepoMate module
+module RepoMate
+
+  # Class for the database
+  class Database
+
+    # Init
+    def initialize(dbfile)
+      @db = SQLite3::Database.new(dbfile)
+    end
+
+    # Checks if the database file already exists
+    def exists?
+      File.exists?(@dbfile)
+    end
+
+    # Executes a query
+    def query(sql)
+      @db.execute(sql)
+    end
+
+    # Deletes a categories directory
+    def destroy
+      FileUtils.rm_r(@dbfile) if exists?
+    end
+  end
+end
+

data/lib/repomate/metafile.rb

@@ -0,0 +1,137 @@
+require 'erb'
+require 'date'
+require 'time'
+require 'gpgme'
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+
+# RepoMate module
+module RepoMate
+
+  # Class that can create and delete all metafiles like Packages, Packages.gz, Release and Release.gpg
+  class Metafile
+
+    # Init
+    def initialize
+      @repository = Repository.new
+    end
+
+    # Returns a lit of all existing metafiles as array
+    def all
+      rootdir  = Cfg.rootdir
+      dirlist  = ["#{rootdir}/*/*", "#{rootdir}/*/*/*/*"]
+      filelist = ["Packages", "Packages.gz", "Release", "Release.gpg" ]
+      files = []
+
+      dirlist.each do |dirs|
+        Dir.glob(dirs).each do |dir|
+          filelist.each do |file|
+            fullname = File.join(dir, file)
+            files << fullname if File.exists? fullname
+          end
+        end
+      end
+      return files
+    end
+
+    # Deletes all existing metafiles
+    def destroy
+      all.each { |file| FileUtils.rm_f(file) }
+    end
+
+    # Creates all metafiles
+    def create
+      destroy
+      create_packages
+
+      if Cfg.gpg_enable
+        if Cfg.gpg_password.nil? || Cfg.gpg_email.nil?
+          puts "Configure password and email for GPG!"
+          exit 1
+        else
+          create_release
+        end
+      end
+    end
+
+    # Create Packages* files
+    def create_packages
+      source_category = "dists"
+
+      packages_template = ERB.new File.new(File.join(File.dirname(__FILE__), "templates/packages.erb")).read, nil, "%"
+
+      Architecture.dataset(source_category).each do |entry|
+        source  = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category)
+        source.files.each do |fullname|
+          package = Package.new(fullname, entry[:suitename], entry[:component])
+
+          checksums = package.get_checksums
+
+          packagesfile = File.join(entry[:fullpath], "Packages")
+          size         = File.size(fullname)
+          path         = File.join("dists", entry[:suitename], entry[:component], entry[:architecture_dir], package.newbasename)
+
+          File.open(packagesfile, 'a') do |file|
+            package.controlfile.each { |key, value| file.puts "#{key}: #{value}" if key }
+            file.puts packages_template.result(binding)
+          end
+          raise "Could not gzip" unless system "gzip -9 -c #{packagesfile} > #{packagesfile}.gz"
+        end
+      end
+    end
+
+    # Create Release* files
+    def create_release
+      source_category = "dists"
+      suites          = []
+
+      archrelease_template  = ERB.new File.new(File.join(File.dirname(__FILE__), "templates/archrelease.erb")).read, nil, "%"
+      suiterelease_template = ERB.new File.new(File.join(File.dirname(__FILE__), "templates/suiterelease.erb")).read, nil, "%"
+
+      now = Time.new.strftime("%a, %d %b %Y %H:%M:%S %Z")
+
+      Architecture.dataset(source_category).each do |entry|
+        releasefile = File.join(entry[:fullpath], "Release")
+
+        suites << entry[:suitename] unless suites.include?(entry[:suitename])
+
+        File.open(releasefile, 'w') { |file| file.puts archrelease_template.result(binding) }
+      end
+
+      suites.each do |suite|
+        architecture = []
+        component    = []
+
+        Architecture.dataset(source_category).each do |entry|
+          if entry[:suitename].eql?(suite)
+            architecture << entry[:architecture] unless architecture.include?(entry[:architecture])
+            component << entry[:component] unless component.include?(entry[:component])
+          end
+        end
+
+        releasefile = File.join(Cfg.rootdir, source_category, suite, "Release")
+
+        File.open(releasefile, 'w') { |file| file.puts suiterelease_template.result(binding).gsub(/^\s+\n|^\n|^\s{3}/, '') }
+        begin
+          sign(releasefile)
+        rescue
+          destroy
+          create_packages
+          puts "GPG email/password incorrect"
+          return
+        end
+      end
+    end
+
+    # Sign a file
+    def sign(file)
+      crypto = GPGME::Crypto.new :password => Cfg.gpg_password
+      outfile = "#{file}.gpg"
+      output = File.open(outfile, 'w')
+      crypto.sign File.open(file, 'r'), :symmetric => false, :output => output, :signer => Cfg.gpg_email, :mode => GPGME::SIG_MODE_DETACH
+    end
+
+  end
+end
+

data/lib/repomate/package.rb

@@ -0,0 +1,116 @@
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'tempfile'
+require 'date'
+require 'time'
+
+# RepoMate module
+module RepoMate
+
+  # Class for reading debian packages
+  class Package
+
+    attr_reader :name, :basename, :newbasename, :controlfile, :architecture, :version, :suitename, :component, :fullname
+
+    # Init
+    def initialize(fullname, suitename, component)
+      @fullname   = fullname
+      @suitename  = suitename
+      @component  = component
+      @basename   = File.basename(fullname)
+      @mtime      = File.mtime(fullname)
+      @pkgdbfile  = File.join(Cfg.rootdir, "packages.db")
+      @pkgdb      = Database.new(@pkgdbfile)
+
+      check_package
+      create_table
+
+      @controlfile  = read_controlfile
+      @name         = @controlfile['Package']
+      @version      = @controlfile['Version']
+      @architecture = @controlfile['Architecture']
+      @newbasename  = "#{@name}-#{@version}_#{@architecture}.deb"
+    end
+
+    # Create the package table
+    def create_table
+      sql = "create table if not exists checksums (
+              date varchar(25),
+              basename varchar(70),
+              mtime varchar(25),
+              md5 varchar(32),
+              sha1 varchar(40),
+              sha256 varchar(64)
+      )"
+      @pkgdb.query(sql)
+    end
+
+    # Gets checksums for the given package
+    def get_checksums
+      result = []
+
+      @pkgdb.query("select md5, sha1, sha256 from checksums where basename = '#{@basename}' and mtime = '#{@mtime.iso8601}'").each do |row|
+        result = row
+        # puts "Hit: #{@basename} #{result}"
+      end
+      result
+    end
+
+    # Creates the checksums for a package
+    def create_checksums
+      # puts "Ins: #{@basename}"
+      now      = DateTime.now
+      md5      = Digest::MD5.file(@fullname).to_s
+      sha1     = Digest::SHA1.file(@fullname).to_s
+      sha256   = Digest::SHA256.new(256).file(@fullname).to_s
+      @pkgdb.query("insert into checksums values ( '#{now}', '#{@basename}', '#{@mtime.iso8601}', '#{md5}', '#{sha1}', '#{sha256}' )")
+    end
+
+    # Gets checksums for the given package
+    def delete_checksums
+      # puts "Del: #{@basename}"
+      @pkgdb.query("delete from checksums where basename = '#{@basename}'")
+    end
+
+    protected
+
+    # Checks if the given package is a debian package
+    def check_package
+      unless `file --dereference #{@fullname}` =~ /Debian binary package/i
+        puts "File does not exist or is not a Debian package!"
+        false
+      end
+    end
+
+    # Extracts the controlfile and returns is
+    def read_controlfile
+      gzbasename  = "control.tar.gz"
+      basename    = "control"
+      tmpdir      = File.expand_path "#{Dir.tmpdir}/#{Time.now.to_i}#{rand(1000)}/"
+      gzfullname  = File.join(tmpdir, gzbasename)
+      fullname    = File.join(tmpdir, basename)
+
+      controlfile = {}
+
+      FileUtils.mkdir_p(tmpdir)
+
+      begin
+        raise "Could not untar" unless system "ar -p #{@fullname} #{gzbasename} > #{gzfullname}"
+        raise Errno::ENOENT, "Package file does not exist" unless File.exists?(gzfullname)
+        raise "Could not untar" unless system "tar xfz #{gzfullname} -C #{tmpdir}"
+
+        File.open(fullname) do |file|
+          while(line = file.gets)
+            line =~ %r{([a-zA-Z]+):\s(.*)}
+            controlfile[$1] = $2
+          end
+        end
+      ensure
+        FileUtils.rm_rf(tmpdir)
+      end
+      controlfile
+    end
+  end
+end
+

data/lib/repomate/repository.rb

@@ -0,0 +1,49 @@
+# RepoMate module
+module RepoMate
+
+  # Class for creating the repository structure
+  class Repository
+
+    attr_reader :categories
+
+    # Init
+    def initialize
+      @categories = ["stage", "pool", "dists"]
+    end
+
+    # Creates the base structure
+    def create(suitename=nil, component=nil, architecture=nil)
+      unless Suite.allowed.include?(suitename)
+        STDERR.puts "Suitename (#{suitename}) is not configured"
+        exit 1
+      end
+
+      unless Component.allowed.include?(component)
+        STDERR.puts "Component (#{component}) is not configured"
+        exit 1
+      end
+
+      unless architecture.nil?
+        unless Architecture.allowed.include?(architecture)
+          STDERR.puts "Architecture (#{architecture}) is not configured"
+          exit 1
+        end
+      end
+
+      @categories.each do |category|
+        if category.eql?("stage")
+          Component.new(component, suitename, category).create
+        else
+          if architecture && component && suitename
+            Architecture.new(architecture, component, suitename, category).create
+          elsif component && suitename
+            Component.new(component, suitename, category).create
+          elsif suitename.nil?
+            Suite.new(suitename, category).create
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/repomate/suite.rb

@@ -0,0 +1,96 @@
+# RepoMate module
+module RepoMate
+
+  # Class for the suite layer of the directory structure
+  class Suite
+
+    # Init
+    def initialize(suitename, category)
+      @suitename  = suitename
+      @category   = category
+    end
+
+    # Returns the given suite name (eg. lenny, squeeze)
+    def name
+      @suitename
+    end
+
+    # Returns the directory strcuture of the suite including all lower layers
+    def directory
+      File.join(Cfg.rootdir, @category, @suitename)
+    end
+
+    # Checks if the suite directory exists
+    def exist?
+      Dir.exist?(directory)
+    end
+
+    # Checks if the suite is allowed (See: configurationfile)
+    def is_allowed?
+      self.allowed.include?(@suitename)
+    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 suite including all lower layers
+    def create
+      FileUtils.mkdir_p(directory) unless exist?
+    end
+
+    # Deletes the suites directory including all lower layers
+    def destroy
+      FileUtils.rm_r(directory) if exist?
+    end
+
+    # Returns a dataset including the name of the suite, the fullpath recursive through all lower layers
+    def self.dataset(category=nil)
+      data   = []
+      self.all.each do |entry|
+        # p entry
+        parts = entry.split(/\//)
+        unless parts.length < 2
+          next unless parts[0].eql?(category) || category.eql?("all")
+
+          data << {
+            :category     => parts[0],
+            :suitename    => parts[1],
+            :fullpath     => File.join(Cfg.rootdir, entry),
+          }
+        end
+      end
+      data
+    end
+
+    # Returns all directories without @rootdir
+    def self.all
+      categories  = Category.all
+      dirs        = []
+      rootdir     = Cfg.rootdir
+      categories.each do |category|
+        suites = Dir.glob(File.join(rootdir, category, "*"))
+        suites.each do |suite|
+          dirs.push suite.gsub(/#{rootdir}\//, '') if File.directory? suite
+        end
+      end
+      return dirs
+    end
+
+    # Gets all configured architectures
+    def self.allowed
+      Cfg.suites.uniq
+    end
+
+  end
+end
+

data/lib/repomate/templates/archrelease.erb

@@ -0,0 +1,6 @@
+Archive: stable
+Component: <%= entry[:component] %>
+Origin: <%= Cfg.origin %>
+Label: <%= Cfg.label %>
+Architecture: <%= entry[:architecture]%>
+Description: Repository for debian <%= entry[:suitename]%>

data/lib/repomate/templates/packages.erb

@@ -0,0 +1,6 @@
+Size: <%= size %>
+Filename: <%= path %>
+MD5sum: <%= checksums[0] %>
+SHA1: <%= checksums[1] %>
+SHA256: <%= checksums[2] %>
+

data/lib/repomate/templates/suiterelease.erb

@@ -0,0 +1,41 @@
+Origin: <%= Cfg.origin %>
+Label: <%= Cfg.label %>
+Suite: stable
+Codename: <%= suite %>
+Date: <%= now %>
+Architectures: <%= architecture.join(', ') %>
+Components: <%= component.join(', ') %>
+Description: Repository for debian
+MD5Sum:
+<% Architecture.dataset(source_category).each do |entry| %>
+  <% source = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category) %>
+  <% Dir.glob(File.join(entry[:fullpath], "Packages*")).each do |file| %>
+    <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::MD5.file(file) %> <%= File.size(file) %> <%= path %>
+  <% end %>
+  <% file = File.join(entry[:fullpath], "Release") %>
+  <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::MD5.file(file) %> <%= File.size(file) %> <%= path %>
+<% end %>
+SHA1:
+<% Architecture.dataset(source_category).each do |entry| %>
+  <% source = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category) %>
+  <% Dir.glob(File.join(entry[:fullpath], "Packages*")).each do |file| %>
+    <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::SHA1.file(file) %> <%= File.size(file) %> <%= path %>
+  <% end %>
+  <% file = File.join(entry[:fullpath], "Release") %>
+  <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::SHA1.file(file) %> <%= File.size(file) %> <%= path %>
+<% end %>
+SHA256:
+<% Architecture.dataset(source_category).each do |entry| %>
+  <% source = Architecture.new(entry[:architecture], entry[:component], entry[:suitename], source_category) %>
+  <% Dir.glob(File.join(entry[:fullpath], "Packages*")).each do |file| %>
+    <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::SHA256.new(256).file(file) %> <%= File.size(file) %> <%= path %>
+  <% end %>
+  <% file = File.join(entry[:fullpath], "Release") %>
+  <% path = File.join(entry[:component], entry[:architecture_dir], File.basename(file)) %>
+    <%= Digest::SHA256.new(256).file(file) %> <%= File.size(file) %> <%= path %>
+<% end %>

data/lib/repomate.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'repomate/architecture'
+require 'repomate/base'
+require 'repomate/category'
+require 'repomate/cli'
+require 'repomate/component'
+require 'repomate/configuration'
+require 'repomate/database'
+require 'repomate/metafile'
+require 'repomate/package'
+require 'repomate/repository'
+require 'repomate/suite'
+