frm 0.0.9 → 0.0.10

data/bin/frm

@@ -24,13 +24,13 @@ FRM allows you to easily create debian repos on S3
 
 Usage: frm [options] package1 [package2] ..."
 
-  options[:access_key] = nil
+  options[:access_key] = ENV['AWS_ACCESS_KEY_ID']
   opts.on( '-a', '--access-key ACCESS_KEY', 'S3 public access key' ) do |key|
     options[:access_key] = key
   end
 
 
-  options[:secret_key] = nil
+  options[:secret_key] = ENV['AWS_SECRET_ACCESS_KEY']
   opts.on( '-s', '--secret-key SECRET_KEY', 'S3 private access key' ) do |key|
     options[:secret_key] = key
   end
@@ -74,7 +74,7 @@ optparse.parse!
 
 
 ARGV.each do |package|
-  packages << File.join(Dir.pwd,package)
+  packages << package
 end
 
 
@@ -87,7 +87,8 @@ end
 print_and_exit "you need to specify at least one package to publish!!!" if packages.empty? 
 
 packages.each do |package|
-  print_and_exit "package '#{package}' does not exits!!!" unless File.exists?(package)
+    puts "package is #{package}"
+  print_and_exit "package '#{package}' does not exist!!!" unless File.exists?(package)
   print_and_exit "package '#{package}' does not appear to be a valid deb" unless system("dpkg --field #{package} > /dev/null 2>&1 ")
 end
 
@@ -95,16 +96,13 @@ end
 # if we have gotten this far it means that all required parameters have been set, so let's begin
 
 
-# chdir to the top level of the code
-Dir.chdir(File.dirname(File.dirname(__FILE__)))
-
 # require the necessary FRM libs
-require File.join Dir.pwd, 'lib', 'frm'
+require_relative '../lib/frm'
 
 puts "creating release..."
-package_release = FRM::PackageRelease.new(packages,options[:release])
+release = FRM::Release.new(options.merge(package_paths: packages))
 
 puts "pushing release..."
-release_pusher = FRM::ReleasePusher.new(package_release,options[:access_key],options[:secret_key],options[:bucket],options[:prefix],options[:public_repo])
+release.push
 
 puts "looks like everything ran ok!"

data/frm.gemspec

@@ -21,6 +21,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency('aws-sdk')
-
+  s.add_runtime_dependency "net-ntp", '~> 2.1.1'	
 end
 

data/lib/frm/arch_release.rb

@@ -0,0 +1,180 @@
+module FRM
+  
+  class ArchRelease < Base
+    attr_reader :opts
+
+    def initialize(opts={})
+      super()
+      @opts = opts
+      @opts[:packages] = []
+      @opts[:package_paths] ||= []
+      @opts[:release] ||= run ". /etc/lsb-release && echo $DISTRIB_CODENAME"
+      @opts[:component] ||= 'main'
+      @opts[:origin] ||= 'FRM'
+      @opts[:lablel] ||= 'FRM'
+      @opts[:description] = "FRM apt repo"
+      @opts[:package_paths].each { |path| @opts[:packages] << Package.new(path) }
+      case run("uname -m")
+      when "x86_64"
+        @opts[:arch] ||= 'amd64'
+      else
+        @opts[:arch] ||= run "uname -m"
+      end
+      raise "you need to pass a remote_store object that responds to exists? and get"\
+         unless @opts[:remote_store] \
+           and @opts[:remote_store].respond_to? 'exists?' \
+           and @opts[:remote_store].respond_to? 'get'
+
+      @opts[:release_file_path] = "#{@opts[:component]}/binary-#{@opts[:arch]}/Release"
+      @opts[:package_file_path] = "#{@opts[:component]}/binary-#{@opts[:arch]}/Packages"
+      @opts[:gzipped_package_file_path] = "#{@opts[:component]}/binary-#{@opts[:arch]}/Packages.gz"
+
+      @opts[:package_file] = merge_package_files
+      @opts[:gzipped_package_file] = generate_gzip_pipe(@opts[:package_file]).read
+      @opts[:release_file] = release_file
+
+      @opts[:package_file_size] = @opts[:package_file].size
+      @opts[:gzipped_package_file_size] = @opts[:gzipped_package_file].size
+      @opts[:release_file_size] = @opts[:release_file].size
+
+      @opts[:package_file_md5sum] = compute_md5(@opts[:package_file])
+      @opts[:gzipped_package_file_md5sum] = compute_md5(@opts[:gzipped_package_file])
+      @opts[:release_file_md5sum] = compute_md5(@opts[:release_file])
+
+      @opts[:package_file_sha1] = compute_sha1(@opts[:package_file])
+      @opts[:gzipped_package_file_sha1] = compute_sha1(@opts[:gzipped_package_file])
+      @opts[:release_file_sha1] = compute_sha1(@opts[:release_file])
+
+      @opts[:package_file_sha256] = compute_sha2(@opts[:package_file])
+      @opts[:gzipped_package_file_sha256] = compute_sha2(@opts[:gzipped_package_file])
+      @opts[:release_file_sha256] = compute_sha2(@opts[:release_file])
+    end
+
+    def push
+      @opts[:packages].each do |p| 
+        if @opts[:remote_store].exists?(p.info['Filename']) 
+          STDERR.puts "package #{p.path} already exists"
+          unless @opts[:remote_store].etag(p.info['Filename']) == p.info['MD5sum']
+            raise <<EOE
+trying to overwrite this package file: #{remote_path}
+local md5 is #{package.info['MD5sum']}
+remote md5 (etag) is #{@s3.etag(remote_path,@bucket)}
+EOE
+          end
+        else
+          STDERR.puts "pushing package #{p.path}"
+          @opts[:remote_store].put(p.info['Filename'],p.content)
+        end
+      end
+      STDERR.puts "pushing arch release files"
+      @opts[:remote_store].put(File.join("dists/#{@opts[:release]}/",@opts[:release_file_path]),@opts[:release_file])
+      @opts[:remote_store].put(File.join("dists/#{@opts[:release]}/",@opts[:gzipped_package_file_path]),@opts[:gzipped_package_file])
+      @opts[:remote_store].put(File.join("dists/#{@opts[:release]}/",@opts[:package_file_path]),@opts[:package_file])
+    end
+    
+    private
+
+    def release_file
+      return <<-EOF
+Component: #{@opts[:component]}
+Origin: #{@opts[:origin]}
+Label: #{@opts[:lablel]}
+Architecture: #{@opts[:arch]}
+Description: #{@opts[:description]}
+EOF
+    end
+
+    def previous_package_file
+      package_file_path = "dists/#{@opts[:release]}/#{@opts[:package_file_path]}"
+      return @opts[:remote_store].get(package_file_path) \
+        if @opts[:remote_store].exists? package_file_path
+      return ""
+    end
+
+    
+    # given a package file as a string, parse out the next package
+    def parse_package_stub(package_file='')
+
+      # find the first package header
+      stub_start = package_file.index(/^Package: /)
+      return nil if stub_start.nil?
+
+      # find the end of the first package section
+      stub_end = package_file.index(/^$/,stub_start)
+      raise "could not parse #{package_file}" if stub_end.nil?
+
+      # extract out the next stub
+      stub = package_file.slice(stub_start,stub_end) + "\n"
+      raise "could not parse #{package_file}" if stub.nil?
+
+      # pull out the package line from the stub
+      package_line = stub[/^Package: .*$/]
+      raise "could not parse #{package_file}" if package_line.nil?
+
+      # pull out the name of the package
+      package = package_line.sub('Package: ','').strip
+      raise "could not read package name from #{stub}" if package.empty?
+
+      return stub, stub_end, package
+    end
+
+
+    # recursive function to merge two sets of packages
+    def merge_package_files(opts={})
+
+      # initial settings
+      opts[:previous_package_file] ||= previous_package_file
+      opts[:new_packages] ||= @opts[:packages].collect{|p| p.to_h}.sort{|a,b| a['Package'] <=> b['Package'] }
+      opts[:new_package_file] ||= ""
+
+      # if we are at the end of both the old package list and the new set of packages then finish
+      return opts[:new_package_file] \
+        if opts[:previous_package_file].strip.empty? \
+          and opts[:new_packages].empty? 
+
+      # if we don't have any new packages to add then return the current list with the old appended
+      return (opts[:new_package_file] << opts[:previous_package_file]) \
+        if opts[:new_packages].empty?
+          
+      # parse next package stub
+      stub, stub_end, next_package = parse_package_stub(opts[:previous_package_file])
+
+      # if we don't have and more old packages to add then return the
+      # current list with the new appended
+      return (opts[:new_package_file] << opts[:new_packages].collect{|p| FRM::Package.hash_to_stub(p)}.join("\n")) if stub.nil?
+
+      # compare the next previous existing pacakge to the next new package
+      case next_package <=> opts[:new_packages].first['Package']
+      when -1 
+        opts[:new_package_file] << stub
+        opts[:previous_package_file].slice!(0..stub_end)
+      when 1
+        opts[:new_package_file] << FRM::Package.hash_to_stub(opts[:new_packages].shift) 
+      when 0
+        # both packages have the same name
+        STDERR.puts "I see two version of this pakcage: #{next_package}"
+        previous_version_line = stub[/^Version: .*$/]
+        raise "could not get version from package stub: \n#{stub}" if previous_version_line.nil?
+
+        previous_version_raw = previous_version_line.sub('Version: ','').strip
+        raise "could not get version from package stub: \n#{stub}" if previous_version_raw.empty?
+        previous_version = Gem::Version.new(previous_version_raw)
+
+        newer_version_raw = opts[:new_packages].first['Version']
+        newer_version = Gem::Version.new(newer_version_raw)
+
+        raise "previous version #{previous_version_raw} is equal to #{newer_version_raw}. Exiting..." \
+          if previous_version == newer_version
+
+        raise "previous version #{previous_version_raw} is newer than #{newer_version_raw}. Exiting..." \
+          if previous_version > newer_version
+        
+        opts[:new_package_file] << FRM::Package.hash_to_stub(opts[:new_packages].shift)
+        opts[:previous_package_file].slice!(0..stub_end)
+      end
+
+      return merge_package_files(opts)
+    end
+
+  end
+end

data/lib/frm/base.rb

@@ -1,5 +1,8 @@
 module FRM
   class Base
+    def initialize
+      @retries = 3
+    end
     
     def compute_md5(string)
       Digest::MD5.hexdigest(string)
@@ -58,80 +61,24 @@ module FRM
       return unzipped_string
     end
     
-    def parse_package_stub(read_buffer)
-      package = {}
-      stub = ""
-      while line = read_buffer.gets
-        return nil if line.strip.empty? 
-        raise "bad input" unless (match = line.match /^\w+\-?\w+?: /)
-        stub << line
-        key = match[0].delete ': ' # if match
-        value = match.post_match.strip
-        package[key] = value
-        if key == 'Description'
-          while (line = read_buffer.gets).strip != ""
-            package['Description'] << line
-            stub << line
-          end
-          package['Description'].rstrip!
-          return package, stub
+    def handle_errors(&block)
+      retries = 0
+      begin
+        yield
+      rescue Object => error_object
+        if retries < @retries
+          sleep(2**retries * 1) #exponential backoff, 1s base
+          retries += 1
+          STDERR.puts "encountered error #{error_object.inspect}, retrying attempt #{retries}."
+          retry
+        else
+          logger.error "encountered error #{error_object.inspect}, aborting."
+          raise error_object
         end
       end
-      nil
-    end
-    
-    def merge_package_file(in_pipe,out_pipe,package_list)
-      sorted_list = package_list.sort { |a,b| a['Package'] <=> b['Package'] }
-      merge(in_pipe,out_pipe,sorted_list)
     end
-    
-    private 
-
-    def create_package_stub(package_hash)
-      return_value = ''
-      package_hash.each do |key,value|
-        return_value << "#{key}: #{value}\n"
-      end
-      return_value << "\n"
-    end
-
-    def merge(in_pipe,out_pipe,package_list)
-      return if out_pipe.closed? 
-      return if in_pipe.closed? and package_list.empty
 
-      if package_list.empty? 
-        while line = in_pipe.gets
-          out_pipe.puts line
-        end
-        in_pipe.close
-        out_pipe.close
-        return
-      end
-
-      if in_pipe.closed? 
-        package_list.each {|package_hash| out_pipe.write(create_package_stub(package_hash)) }
-        out_pipe.close 
-        return
-      end
-      
-      current_package, stub = parse_package_stub in_pipe
-
-      if current_package['Package'] < package_list.first['Package']
-        out_pipe.puts stub
-        out_pipe.puts ""
-        merge(in_pipe,out_pipe,package_list)
-        return
-      elsif current_package['Package'] > package_list.first['Package']
-        while ( ! package_list.empty? ) and current_package['Package'] > package_list.first['Package'] 
-          out_pipe.write create_package_stub(package_list.shift)
-        end
-      elsif current_package['Package'] == package_list.first['Package']
-        out_pipe.write create_package_stub(package_list.shift)
-      end
-      
-      merge(in_pipe,out_pipe,package_list)
-      return nil 
-    end
+    private 
     
   end
 end

data/lib/frm/package.rb

@@ -1,12 +1,15 @@
 module FRM
   class Package < Base
-    attr_accessor :repo_filename
-    attr_reader :path, :content, :md5, :sha1, :sha2 , :size, :release
-    def initialize(path,release='natty')
-      raise "you need to specify a path!!!" if path.nil?
+    attr_reader :path, :content, :info
+
+    def initialize(path)
       @path = path
-      raise "Can not find file '#{path}'" unless File.exists?(path)
-      @release = release
+
+      raise "you need to pass a path!!!" if path.nil?
+      raise "Can not find file: '#{path}'" unless File.exists?(path)
+      raise "this system does not have the dpkg binary" unless system 'which dpkg > /dev/null'
+      raise "file #{path} is not a deb" unless system "dpkg --field #{path} > /dev/null"
+
       begin
         @content = File.read(path)
       rescue Object => o
@@ -15,10 +18,37 @@ module FRM
         STDERR.puts o.backtrace
         raise "Could not open file '#{path}'. Exiting..."
       end
-      @size = File.size(@path)
-      @md5 = compute_md5(@content)
-      @sha1 = compute_sha1(@content)
-      @sha2 = compute_sha2(@content)
+
+      @info = get_package_info
     end
+
+    def to_stub
+      @info.collect{|k,v| "#{k}: #{v}"}.join("\n") + "\n\n"
+    end
+
+    def self.hash_to_stub(hash)
+      hash.collect{|k,v| "#{k}: #{v}"}.join("\n") + "\n\n"
+    end
+
+    def to_h
+      return @info
+    end
+
+    private 
+
+    def get_package_info
+      h = {}
+      ['Package', 'Version', 'License' ,'Vendor' ,'Architecture' ,'Maintainer', 'Installed-Size' ,'Section', 'Priority', 'Homepage', 'Description' ].each do |value| 
+        h[value] = run "dpkg --field #{@path} #{value}"
+      end
+
+      h['Filename'] = "pool/main/#{h['Package'][0]}/#{h['Package']}/#{File.basename @path}"
+      h['Size'] = File.size(@path)
+      h['MD5sum'] = compute_md5(@content)
+      h['SHA1'] = compute_sha1(@content)
+      h['SHA256'] = compute_sha2(@content)
+      return h
+    end
+
   end
 end

data/lib/frm/release_pusher.rb

@@ -14,28 +14,44 @@ module FRM
 
 
     def push_release_files(package_release)
-      # TODO: un-hardcode this
       release_path = @prefix + "/dists/#{@release}/Release"
-      @s3.put(release_path,package_release.release_file,@bucket)
-
       in_release_path = @prefix + "/dists/#{@release}/InRelease"
-      @s3.put(in_release_path,gpg_clearsign(package_release.release_file),@bucket)
-
       gpg_release_path = @prefix + "/dists/#{@release}/Release.gpg"
-      @s3.put(gpg_release_path,gpg_detached(package_release.release_file),@bucket)
-
-      release_file_path = @prefix + "/dists/#{@release}/" + package_release.component
-      @s3.put(release_file_path + '/Release',package_release.short_release_file,@bucket)
-      @s3.put(release_file_path + '/Packages',package_release.package_file,@bucket)
-      @s3.put(release_file_path + '/Packages.gz',package_release.gzipped_package_file,@bucket)
 
+      unless @s3.exists?(release_path,@bucket)
+        STDERR.puts "pushing new release files..."
+        @s3.put(release_path,package_release.release_file,@bucket)
+        @s3.put(in_release_path,gpg_clearsign(package_release.release_file),@bucket)
+        @s3.put(gpg_release_path,gpg_detached(package_release.release_file),@bucket)
+        
+        
+        release_file_path = @prefix + "/dists/#{@release}/" + package_release.component
+        @s3.put(release_file_path + '/Release',package_release.short_release_file,@bucket)
+        @s3.put(release_file_path + '/Packages',package_release.package_file,@bucket)
+        @s3.put(release_file_path + '/Packages.gz',package_release.gzipped_package_file,@bucket)
+        
+        
+        i386_release_file_path = @prefix + "/dists/#{@release}/" + 'main/binary-i386'
+        @s3.put(i386_release_file_path + '/Release',package_release.i386_release_file,@bucket)
+        @s3.put(i386_release_file_path + '/Packages',package_release.i386_packages_file,@bucket)
+        @s3.put(i386_release_file_path + '/Packages.gz',package_release.gzipped_i386_packages_file,@bucket)
+        
+        # push public key
+        @s3.put(@prefix + '/public.key',gpg_export_pubkey,@bucket)
+      else
+        STDERR.puts "updating releases file"
+        release_file = @s3.get(release_path,@bucket)
+        File.open('/tmp/in','w'){ |f|
+          f.write(release_file)
+        }
+        in_buffer = File.open('/tmp/in',"r")
+        out_buffer = File.open('/tmp/fd',"w")
+        STDERR.puts "package_release.packages is #{package_release.packages.inspect}"
+        merge_package_file(in_buffer,out_buffer,package_release.packages)
 
-      i386_release_file_path = @prefix + "/dists/#{@release}/" + 'main/binary-i386'
-      @s3.put(i386_release_file_path + '/Release',package_release.i386_release_file,@bucket)
-      @s3.put(i386_release_file_path + '/Packages',package_release.i386_packages_file,@bucket)
-      @s3.put(i386_release_file_path + '/Packages.gz',package_release.gzipped_i386_packages_file,@bucket)
-      # push public key
-      @s3.put(@prefix + '/public.key',gpg_export_pubkey,@bucket)
+        STDERR.puts "not yet implmented"
+        Kernel.exit 1
+      end
     end
     
 
@@ -44,8 +60,19 @@ module FRM
     end
     
     def push_package(package)
-      remote_path = @prefix + '/' + package.repo_filename
-      @s3.put(remote_path,package.content,@bucket)
+      remote_path = @prefix + '/' + package.info['Filename']
+      if @s3.exists?(remote_path,@bucket) 
+        unless @s3.etag(remote_path,@bucket) == package.info['MD5sum']
+          error_message = <<EOE
+trying to overwrite this package file: #{remote_path}
+local md5 is #{package.info['MD5sum']}
+remote md5 (etag) is #{@s3.etag(remote_path,@bucket)}
+EOE
+          raise error_message
+        end
+      else
+        @s3.put(remote_path,package.content,@bucket)
+      end
     end
     
 

data/lib/frm/s3.rb

@@ -3,76 +3,73 @@ require 'aws-sdk'
 module FRM
   class S3  < Base
 
-    attr_reader :max_retries, :s3, :acl
-
-    def initialize(access_key_id,secret_access_key,public_repo=false)
-      @max_retries = 10
-      AWS.config(:access_key_id => access_key_id, 
-                 :secret_access_key => secret_access_key)
+    def initialize(opts={})
+      super()
+      @opts = opts
+      @opts[:public_repo] ||= false
+      @opts[:acl] = @opts[:public_repo] ? :public_read : :private
+      @opts[:aws_access_key] ||= ENV['AWS_ACCESS_KEY_ID']
+      @opts[:aws_secret_key] ||= ENV['AWS_SECRET_ACCESS_KEY']
+      raise "you either need to pass an aws_access_key option or set the AWS_ACCESS_KEY environment variable" \
+        if @opts[:aws_access_key].nil?
+      raise "you either need to pass an aws_secret_key option or set the AWS_SECRET_KEY environment variable" \
+        if @opts[:aws_secret_key].nil?
+      raise "you need to pass in a bucket param" unless @opts[:bucket]
+      raise "you need to pass in a prefix param" unless @opts[:prefix]
+      @opts[:prefix] << '/' unless @opts[:prefix][-1] == '/'
+      AWS.config(:access_key_id => @opts[:access_key_id], 
+                 :secret_access_key => @opts[:secret_access_key])
       @s3 = AWS::S3.new
-      @acl = public_repo ? :public_read : :private
     end
-
     
-    def key?(key,bucket)
-      @s3.buckets[bucket].objects[key].exists?
+    def exists?(relative_path)
+      handle_errors do 
+        return @s3.buckets[@opts[:bucket]].objects[full_path(relative_path)].exists?
+      end
     end
 
-    
-    def put(key,value,bucket)
-      @max_retries.times do |i|
-        begin
-          @s3.buckets[bucket].objects[key].write(value,acl: @acl)
-          return true
-        rescue Object => o
-          print_retry(__method__,o)
-        end
-        raise "could not put object!!!" if i == (@max_retries - 1)
+    def etag(relative_path)
+      quoted_etag = ""
+      handle_errors do 
+        quoted_etag = @s3.buckets[@opts[:bucket]].objects[full_path(relative_path)].etag
       end
-      raise "could not put object!!!"
+      # stupid method call is actually putting quotes in the string,
+      # so let's remove those:
+      return quoted_etag.gsub(/"/,'')
     end
-    
-    
-    def get(key,bucket)
-      @max_retries.times do |i|
-        begin
-          return @s3.buckets[bucket].objects[key].read
-        rescue Object => o
-          print_retry(__method__,o)
-        end
-        raise "could not get object!!!" if i == (@max_retries - 1)
+
+    def put(relative_path,value)
+      handle_errors do 
+        @s3.buckets[@opts[:bucket]].objects[full_path(relative_path)].write(value,acl: @opts[:acl]) # 
       end
-      raise "could not get object!!!"
+      return true
     end
     
+    def get(relative_path)
+      handle_errors do 
+        return @s3.buckets[@opts[:bucket]].objects[full_path(relative_path)].read
+      end
+    end
     
-    def delete(key,bucket)
-      begin
-        @s3.buckets[bucket].objects[object].delete
-        return true
-      rescue Object => o
-        print_retry(__method__,o)
+    def delete(relative_path)
+      handle_errors do 
+        @s3.buckets[@opts[:bucket]].objects[full_path(relative_path)].delete
       end
+      return true
     end
 
-
-    def move(old_key,new_key,bucket)
-      begin
-        @s3.buckets[bucket].objects[old_key].move_to(new_key)
-        return true
-      rescue Object => o
-        print_retry(__method__,o)
+    def move(old_relative_path,new_relative_path)
+      handle_errors do
+        @s3.buckets[@opts[:bucket]].objects[full_path(old_relative_path)].move_to(new_relative_path)
       end
+      return true
     end
 
     protected
 
-    def print_retry(action,error)
-      STDERR.puts "coudld not #{action} object because of:"
-      STDERR.puts error.inspect
-      STDERR.puts ", retrying..."
-      sleep 2
+    def full_path(relative_path="")
+      return @opts[:prefix] + relative_path
     end
-    
+
   end
 end

data/lib/frm/version.rb

@@ -1,3 +1,3 @@
 module Frm
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/lib/frm.rb

@@ -1,14 +1,99 @@
-
 require 'zlib'
 require 'tempfile'
 require 'digest/md5'
 require 'digest/sha1'
 require 'digest/sha2'
+require 'logger'
+require 'net/ntp'
 
 require_relative 'frm/base'
 require_relative 'frm/s3'
 require_relative 'frm/package'
-require_relative 'frm/release'
+require_relative 'frm/arch_release'
 require_relative 'frm/release_pusher'
 require_relative 'frm/deb'
 
+
+module FRM
+  class Release < Base
+
+    def initialize(opts={})
+      super()
+      @opts = opts
+      @opts[:component] ||= 'main'
+      @opts[:origin] ||= 'FRM'
+      @opts[:label] ||= 'FRM'
+      @opts[:description] = "FRM apt repo"
+      @opts[:release] ||= run ". /etc/lsb-release && echo $DISTRIB_CODENAME"
+      handle_errors{@time = Net::NTP.get("us.pool.ntp.org").time.getutc}
+
+      case run("uname -m")
+      when "x86_64"
+        @opts[:arch] ||= 'amd64'
+      else
+        @opts[:arch] ||= run "uname -m"
+      end
+
+      @opts[:remote_store] = FRM::S3.new(opts)
+      @arch_releases = [ArchRelease.new(opts)]
+      @arch_releases << ArchRelease.new(arch: 'i386',remote_store: @opts[:remote_store]) \
+        if @opts[:arch] == 'amd64'
+
+      @release_file = release_file
+      @in_release_file = gpg_clearsign(release_file)
+      @release_gpg_file = gpg_detached(release_file)
+
+      @release_file_path = "dists/#{@opts[:release]}/Release"
+      @in_release_file_path = "dists/#{@opts[:release]}/InRelease"
+      @release_gpg_file_path = "dists/#{@opts[:release]}/Release.gpg"
+
+    end
+
+    def push
+      @arch_releases.each {|arch_release| arch_release.push}
+      @opts[:remote_store].put(@release_file_path,@release_file)
+      @opts[:remote_store].put(@in_release_file_path,@in_release_file)
+      @opts[:remote_store].put(@release_gpg_file_path,@release_gpg_file)
+      
+      # push public key
+      @opts[:remote_store].put('public.key',gpg_export_pubkey)
+    end
+
+    def merge
+    end
+    
+    private 
+
+
+    # ubuntu precicse 64 wants i386 debs by default :\
+    def generate_i386_stubs()
+    end
+
+    def release_file()
+      partial_release_file = <<EOF
+Origin: #{@opts[:origin]}
+Label: #{@opts[:label]}
+Codename: #{@opts[:release]}
+Date: #{@time.getutc.strftime("%a, %d %b %Y %H:%M:%S UTC")}
+Architectures: #{@arch_releases.collect{|r| r.opts[:arch]}.join(' ')}
+Components: #{@opts[:component]}
+Description: #{@opts[:description]}
+EOF
+
+      %w{MD5Sum SHA1 SHA256}.each do |hash|
+        partial_release_file << "#{hash}:\n"
+        @arch_releases.each do |arch_release|
+          %w{package gzipped_package release}.each do |file|
+            partial_release_file << " #{arch_release.opts["#{file}_file_#{hash.downcase}".to_sym]} "
+            partial_release_file << arch_release.opts["#{file}_file_size".to_sym].to_s
+            partial_release_file << " "
+            partial_release_file << arch_release.opts["#{file}_file_path".to_sym]
+            partial_release_file << "\n"
+          end
+        end
+      end
+      return partial_release_file
+    end
+    
+  end
+end

data/test/deb.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'minitest/autorun'
-require 'mock-aws-s3'
+#require 'mock-aws-s3'
 
 class TestReleasePusher < MiniTest::Unit::TestCase
   def setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: frm
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2013-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ntp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
 description: FRM makes it easy to build package repositories on S3
 email:
 - ermal14@gmail.com
@@ -43,10 +59,10 @@ files:
 - bin/frm
 - frm.gemspec
 - lib/frm.rb
+- lib/frm/arch_release.rb
 - lib/frm/base.rb
 - lib/frm/deb.rb
 - lib/frm/package.rb
-- lib/frm/release.rb
 - lib/frm/release_pusher.rb
 - lib/frm/s3.rb
 - lib/frm/version.rb

data/lib/frm/release.rb

@@ -1,107 +0,0 @@
-module FRM
-  
-  class PackageRelease < Base
-    attr_reader :packages, :standards_version, :priority, :package_file, :gzipped_package_file, :release_file, :short_release_file, :component, :release, :i386_release_file, :i386_packages_file, :gzipped_i386_packages_file
-    def initialize(packages={},release='natty',component='main/binary-amd64')
-      @release = release
-      @component = component
-      @standards_version = standards_version
-      @priority = priority
-      @packages = []
-      packages.each { |package| @packages << Package.new(package,@release) }
-      if component == 'main/binary-amd64'
-        generate_i386_stubs
-      end
-      @i386_release_file = <<EOF
-Component: main
-Origin: apt.cloudscaling.com
-Label: apt repository #{@release}
-Architecture: i386
-Description: Cloudscaling APT repository
-EOF
-      @i386_packages_file = ""
-      @gzipped_i386_packages_file = generate_gzip_pipe(@i386_packages_file).read
-      @package_file = generate_package_file
-      @gzipped_package_file = generate_gzip_pipe(@package_file).read
-      @short_release_file = generate_short_release_file
-      @release_file = generate_release_file
-    end
-    
-    private
-
-    
-    # ubuntu precicse 64 wants i386 debs by default :\
-    def generate_i386_stubs()
-    end
-
-    
-    def generate_release_file()
-      partial_release_file = "Origin: apt.cloudscaling.com
-Label: apt repository #{@release}
-Codename: #{@release}
-Date: Thu, 22 Dec 2011 00:29:55 UTC
-Architectures: amd64 i386
-Components: main universe multiverse
-Description: Cloudscaling APT repository
-MD5Sum:
- #{compute_md5(@package_file)} #{@package_file.size} #{@component}/Packages
- #{compute_md5(@gzipped_package_file)} #{@gzipped_package_file.size} #{@component}/Packages.gz
- #{compute_md5(@short_release_file)} #{@short_release_file.size} #{@component}/Release
- #{compute_md5(@i386_packages_file)} #{@i386_packages_file.size} main/binary-i386/Packages
- #{compute_md5(@gzipped_i386_packages_file)} #{@gzipped_i386_packages_file.size} main/binary-i386/Packages.gz
- #{compute_md5(@i386_release_file)} #{@i386_release_file.size} main/binary-i386/Release
-SHA1:
- #{compute_sha1(@package_file)} #{@package_file.size} #{@component}/Packages
- #{compute_sha1(@gzipped_package_file)} #{@gzipped_package_file.size} #{@component}/Packages.gz
- #{compute_sha1(@short_release_file)} #{@short_release_file.size} #{@component}/Release
- #{compute_sha1(@i386_packages_file)} #{@i386_packages_file.size} main/binary-i386/Packages
- #{compute_sha1(@gzipped_i386_packages_file)} #{@gzipped_i386_packages_file.size} main/binary-i386/Packages.gz
- #{compute_sha1(@i386_release_file)} #{@i386_release_file.size} main/binary-i386/Release
-SHA256:
- #{compute_sha2(@package_file)} #{@package_file.size} #{@component}/Packages
- #{compute_sha2(@gzipped_package_file)} #{@gzipped_package_file.size} #{@component}/Packages.gz
- #{compute_sha2(@short_release_file)} #{@short_release_file.size} #{@component}/Release
- #{compute_sha2(@i386_packages_file)} #{@i386_packages_file.size} main/binary-i386/Packages
- #{compute_sha2(@gzipped_i386_packages_file)} #{@gzipped_i386_packages_file.size} main/binary-i386/Packages.gz
- #{compute_sha2(@i386_release_file)} #{@i386_release_file.size} main/binary-i386/Release
-"
-      return partial_release_file
-    end
-
-
-    def generate_short_release_file
-      "Component: main
-Origin: apt.cloudscaling.com
-Label: apt repository #{@release}
-Architecture: amd64
-Description: Cloudscaling APT repository
-"
-    end
-    
-
-    def filename(package)
-      filename = File.basename package.path
-      shortname = run("dpkg --field #{package.path} Package")
-      first_letter = shortname[0]
-      package.repo_filename = "pool/main/#{first_letter}/#{shortname}/#{filename}"
-    end
-    
-    def generate_package_file()
-      package_file = ''
-      @packages.each { |package| package_file << generate_package_stub(package) }
-      return package_file
-    end
-    
-    def generate_package_stub(package)
-      package_stub = ''
-      package_stub << run("dpkg --field #{package.path}") + "\n"
-      package_stub << "Filename: #{filename(package)}\n"
-      package_stub << "Size: #{package.size}\n"
-      package_stub << "MD5sum: #{package.md5}\n"
-      package_stub << "SHA1: #{package.sha1}\n"
-      package_stub << "SHA256: #{package.sha2}\n"
-      package_stub << "\n"
-      return package_stub
-    end
-  end
-end