deb-fog 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWMwZjlmN2FiZWM3Y2FlOThlOWE1ZjczOTk1YmVjOWM4ZjAzY2I0Mg==
+  data.tar.gz: !binary |-
+    NDNiNDRiOGIwNTYxYTAzNjZhMGNmMDFiZjZiZjU4MzE5OThlYzcxYg==
+SHA512:
+  metadata.gz: !binary |-
+    ZGQwZWJkMjhiOThlMjk4MjlkYTkxODRhMzcwZmU2OGUwODI5NWU5MWU4YjRh
+    MDQyYmI2MGI5NjNlOGY3YjAwMmU2ODYzODEzYzU3NjY0YmQ3ZWE0ZDkxNDFh
+    N2E4YjNmOGEwMzIxNjU5YzQ3YjUyMmQxYzMzZTgzODZkOWUzMzk=
+  data.tar.gz: !binary |-
+    YjMyY2E1MDg3YmY2MWM5YTY1MjM4MDM5NDJmM2NhMmMwMDlmMWViYWZlNDQ0
+    NDk2MmU2OWRhYTg4NWQ2MThkOTViM2YyZmQ5N2I1NDQ3MDBmOWM4OGI5ODIx
+    NGE4MzlmYTdiMGU3YzEwMjdhYzA3YzUwMTY4NWUxNmQ2MTVhNzc=

data/README.md

@@ -0,0 +1,139 @@
+# deb-fog
+
+`deb-fog` is a simple utility to make creating and managing APT repositories on
+Cloud object storage platforms.   It is based on a fork of the `deb-fog` repository found [here](https://github.com/krobertson/deb-fog)
+
+Most existing existing guides on using object storage to host an APT repository have you
+using something like [reprepro](http://mirrorer.alioth.debian.org/) to generate
+the repository file structure, and then [s3cmd](http://s3tools.org/s3cmd) or similar to sync the files to object storage.
+
+The annoying thing about this process is it requires you to maintain a local
+copy of the file tree for regenerating and syncing the next time. Personally,
+my process is to use one-off virtual machines with
+[Vagrant](http://vagrantup.com), script out the build process, and then would
+prefer to just upload the final `.deb` from my Mac.
+
+With `deb-fog`, there is no need for this. `deb-fog` features:
+
+* Downloads the existing package manifest and parses it.
+* Updates it with the new package, replacing the existing entry if already
+  there or adding a new one if not.
+* Uploads the package itself, the Packages manifest, and the Packages.gz
+  manifest.
+* Updates the Release file with the new hashes and file sizes.
+
+## Getting Started
+
+You can simply install it from rubygems:
+
+```console
+$ gem install deb-fog
+```
+
+Or to run the code directly, just check out the repo and run Bundler to ensure
+all dependencies are installed:
+
+```console
+$ git clone https://github.com/krobertson/deb-fog.git
+$ cd deb-fog
+$ bundle install
+```
+
+Now to upload a package, simply use:
+
+```console
+$ deb-fog upload --provider Rackspace --bucket my-bucket my-deb-package-1.0.0_amd64.deb
+>> Examining package file my-deb-package-1.0.0_amd64.deb
+>> Retrieving existing package manifest
+>> Uploading package and new manifests to S3
+   -- Transferring pool/m/my/my-deb-package-1.0.0_amd64.deb
+   -- Transferring dists/stable/main/binary-amd64/Packages
+   -- Transferring dists/stable/main/binary-amd64/Packages.gz
+   -- Transferring dists/stable/Release
+>> Update complete.
+```
+
+```
+Usage:
+  deb-fog upload FILES
+
+Options:
+  -a, [--arch=ARCH]                     # The architecture of the package in the APT repository.
+      [--sign=SIGN]                     # Sign the Release file. Use --sign with your key ID to use a specific key.
+  -p, [--preserve-versions]             # Whether to preserve other versions of a package in the repository when uploading one.
+  -b, [--bucket=BUCKET]                 # The name of the S3 bucket to upload to.
+  -c, [--codename=CODENAME]             # The codename of the APT repository.
+                                        # Default: stable
+  -m, [--component=COMPONENT]           # The component of the APT repository.
+                                        # Default: main
+      [--access-key-id=ACCESS_KEY]      # The access key or username for
+                                        # authenticating with your cloud 
+                                        # platform
+      [--secret-access-key=SECRET_KEY]  # The secret key or API key for 
+                                        # authenticating with your cloud 
+                                        # platform
+      [--provider=CLOUD_PROVIDER]       # the cloud to connect to Rackspace|AWS
+  -v, [--visibility=VISIBILITY]         # The access policy for the uploaded 
+  files. Can be public, private, or authenticated.
+                                        # Default: public
+
+Uploads the given files to a S3 bucket as an APT repository.
+```
+
+You can also delete packages from the APT repository. Please keep in mind that
+this does NOT delete the .deb file itself, it only removes it from the list of
+packages in the specified component, codename and architecture.
+
+Now to delete the package:
+```console
+$ deb-fog delete --provider Rackspace --arch amd64 --bucket my-bucket --versions 1.0.0 my-deb-package
+>> Retrieving existing manifests
+   -- Deleting my-deb-package version 1.0.0
+>> Uploading new manifests to S3
+   -- Transferring dists/stable/main/binary-amd64/Packages
+   -- Transferring dists/stable/main/binary-amd64/Packages.gz
+   -- Transferring dists/stable/Release
+>> Update complete.
+
+````
+
+You can also verify an existing APT repository on S3 using the `verify` command:
+
+```console
+deb-fog verify --provider Rackspace -b my-bucket
+>> Retrieving existing manifests
+>> Checking for missing packages in: stable/main i386
+>> Checking for missing packages in: stable/main amd64
+>> Checking for missing packages in: stable/main all
+```
+
+```
+Usage:
+  deb-fog verify
+
+Options:
+  -f, [--fix-manifests]                 # Whether to fix problems in manifests when verifying.
+      [--sign=SIGN]                     # Sign the Release file. Use --sign with your key ID to use a specific key.
+  -b, [--bucket=BUCKET]                 # The name of the S3 bucket to upload to.
+  -c, [--codename=CODENAME]             # The codename of the APT repository.
+                                        # Default: stable
+  -m, [--component=COMPONENT]           # The component of the APT repository.
+                                        # Default: main
+      [--access-key-id=ACCESS_KEY]      # The access key or username for
+                                        # authenticating with your cloud 
+                                        # platform
+      [--secret-access-key=SECRET_KEY]  # The secret key or API key for 
+                                        # authenticating with your cloud 
+                                        # platform
+      [--provider=CLOUD_PROVIDER]       # the cloud to connect to Rackspace|AWS
+  -v, [--visibility=VISIBILITY]         # The access policy for the uploaded files. Can be public, private, or authenticated.
+                                        # Default: public
+
+Verifies that the files in the package manifests exist
+```
+
+## TODO
+
+This is still experimental.  These are several things to be done:
+
+* Don't re-upload a package if it already exists and has the same hashes.

data/bin/deb-fog

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'deb/fog/cli'
+
+Deb::Fog::CLI.start
+

data/lib/deb/fog.rb

@@ -0,0 +1,5 @@
+module Deb
+  module Fog
+    VERSION = "0.1.0"
+  end
+end

data/lib/deb/fog/cli.rb

@@ -0,0 +1,306 @@
+require "fog"
+require "thor"
+
+# Hack: aws requires this!
+require "json"
+
+require "deb/fog"
+require "deb/fog/utils"
+require "deb/fog/manifest"
+require "deb/fog/package"
+require "deb/fog/release"
+
+class Deb::Fog::CLI < Thor
+  class_option :bucket,
+  :type     => :string,
+  :aliases  => "-b",
+  :desc     => "The name of the Fog bucket to upload to."
+
+  class_option :prefix,
+  :type     => :string,
+  :desc     => "The path prefix to use when storing on Fog."
+
+  class_option :codename,
+  :default  => "stable",
+  :type     => :string,
+  :aliases  => "-c",
+  :desc     => "The codename of the APT repository."
+
+  class_option :component,
+  :default  => "main",
+  :type     => :string,
+  :aliases  => "-m",
+  :desc     => "The component of the APT repository."
+
+  class_option :section,
+  :type     => :string,
+  :aliases  => "-s",
+  :hide     => true
+
+  class_option :provider,
+  :type     => :string,
+  :desc     => "The Cloud Provider to use: AWS|Google|Rackspace"
+
+  class_option :access_key_id,
+  :type     => :string,
+  :desc     => "The access key for connecting to Fog."
+
+  class_option :secret_access_key,
+  :type     => :string,
+  :desc     => "The secret key for connecting to Fog."
+
+  class_option :endpoint,
+  :type     => :string,
+  :desc     => "The region endpoint for connecting to Fog.",
+  :default  => "fog.amazonaws.com"
+
+  class_option :visibility,
+  :default  => "public",
+  :type     => :string,
+  :aliases  => "-v",
+  :desc     => "The access policy for the uploaded files. " +
+    "Can be public, private, or authenticated."
+
+  class_option :sign,
+  :type     => :string,
+  :desc     => "Sign the Release file when uploading a package," +
+    "or when verifying it after removing a package." +
+    "Use --sign with your key ID to use a specific key."
+
+  class_option :gpg_options,
+  :default => "",
+  :type    => :string,
+  :desc    => "Additional command line options to pass to GPG when signing"
+
+  desc "upload FILES",
+  "Uploads the given files to a Fog bucket as an APT repository."
+
+  option :arch,
+  :type     => :string,
+  :aliases  => "-a",
+  :desc     => "The architecture of the package in the APT repository."
+
+  option :preserve_versions,
+  :default  => false,
+  :type     => :boolean,
+  :aliases  => "-p",
+  :desc     => "Whether to preserve other versions of a package " +
+    "in the repository when uploading one."
+
+  def upload(*files)
+    component = options[:component]
+    if options[:section]
+      component = options[:section]
+      warn("===> WARNING: The --section/-s argument is deprecated, please use --component/-m.")
+    end
+
+    if files.nil? || files.empty?
+      error("You must specify at least one file to upload")
+    end
+
+    # make sure all the files exists
+    if missing_file = files.detect { |f| !File.exists?(f) }
+      error("File '#{missing_file}' doesn't exist")
+    end
+
+    # configure AWS::Fog
+    configure_fog_client
+
+    # retrieve the existing manifests
+    log("Retrieving existing manifests")
+    release  = Deb::Fog::Release.retrieve(options[:codename])
+    manifests = {}
+
+    # examine all the files
+    files.collect { |f| Dir.glob(f) }.flatten.each do |file|
+      log("Examining package file #{File.basename(file)}")
+      pkg = Deb::Fog::Package.parse_file(file)
+
+      # copy over some options if they weren't given
+      arch = options[:arch] || pkg.architecture
+
+      # validate we have them
+      error("No architcture given and unable to determine one for #{file}. " +
+            "Please specify one with --arch [i386,amd64].") unless arch
+
+      # retrieve the manifest for the arch if we don't have it already
+      manifests[arch] ||= Deb::Fog::Manifest.retrieve(options[:codename], component, arch)
+
+      # add in the package
+      manifests[arch].add(pkg, options[:preserve_versions])
+    end
+
+    # upload the manifest
+    log("Uploading packages and new manifests to Fog")
+    manifests.each_value do |manifest|
+      manifest.write_to_fog { |f| sublog("Transferring #{f}") }
+      release.update_manifest(manifest)
+    end
+    release.write_to_fog { |f| sublog("Transferring #{f}") }
+
+    log("Update complete.")
+  end
+
+  desc "delete PACKAGE",
+    "Remove the package named PACKAGE. If --versions is not specified, delete" +
+    "all versions of PACKAGE. Otherwise, only the specified versions will be " +
+    "deleted."
+
+  option :arch,
+    :type     => :string,
+    :aliases  => "-a",
+    :desc     => "The architecture of the package in the APT repository."
+
+  option :versions,
+    :default  => nil,
+    :type     => :array,
+    :desc     => "The space-delimited versions of PACKAGE to delete. If not" +
+    "specified, ALL VERSIONS will be deleted. Fair warning." +
+    "E.g. --versions \"0.1 0.2 0.3\""
+
+  def delete(package)
+    component = options[:component]
+    if options[:section]
+      component = options[:section]
+      warn("===> WARNING: The --section/-s argument is deprecated, please use --component/-m.")
+    end
+
+    if package.nil?
+      error("You must specify a package name.")
+    end
+
+    versions = options[:versions]
+    if versions.nil?
+      warn("===> WARNING: Deleting all versions of #{package}")
+    else
+      log("Versions to delete: #{versions.join(', ')}")
+    end
+
+    arch = options[:arch]
+    if arch.nil?
+      error("You must specify the architecture of the package to remove.")
+    end
+
+    configure_fog_client
+
+    # retrieve the existing manifests
+    log("Retrieving existing manifests")
+    release  = Deb::Fog::Release.retrieve(options[:codename])
+    manifest = Deb::Fog::Manifest.retrieve(options[:codename], component, options[:arch])
+
+    deleted = manifest.delete_package(package, versions)
+    if deleted.length == 0
+        if versions.nil?
+            error("No packages were deleted. #{package} not found.")
+        else
+            error("No packages were deleted. #{package} versions #{versions.join(', ')} could not be found.")
+        end
+    else
+        deleted.each { |p|
+            sublog("Deleting #{p.name} version #{p.version}")
+        }
+    end
+
+    log("Uploading new manifests to Fog")
+    manifest.write_to_fog {|f| sublog("Transferring #{f}") }
+    release.update_manifest(manifest)
+    release.write_to_fog {|f| sublog("Transferring #{f}") }
+
+    log("Update complete.")
+  end
+
+
+  desc "verify", "Verifies that the files in the package manifests exist"
+
+  option :fix_manifests,
+  :default  => false,
+  :type     => :boolean,
+  :aliases  => "-f",
+  :desc     => "Whether to fix problems in manifests when verifying."
+
+  def verify
+    component = options[:component]
+    if options[:section]
+      component = options[:section]
+      warn("===> WARNING: The --section/-s argument is deprecated, please use --component/-m.")
+    end
+
+    configure_fog_client
+
+    log("Retrieving existing manifests")
+    release = Deb::Fog::Release.retrieve(options[:codename])
+
+    %w[amd64 armel i386 all].each do |arch|
+      log("Checking for missing packages in: #{options[:codename]}/#{options[:component]} #{arch}")
+      manifest = Deb::Fog::Manifest.retrieve(options[:codename], component, arch)
+      missing_packages = []
+
+      manifest.packages.each do |p|
+        unless Deb::Fog::Utils.fog_exists? p.url_filename_encoded
+          sublog("The following packages are missing:\n\n") if missing_packages.empty?
+          puts(p.generate)
+          puts("")
+
+          missing_packages << p
+        end
+      end
+
+      if options[:fix_manifests] && !missing_packages.empty?
+        log("Removing #{missing_packages.length} package(s) from the manifest...")
+        missing_packages.each { |p| manifest.packages.delete(p) }
+        manifest.write_to_fog { |f| sublog("Transferring #{f}") }
+        release.update_manifest(manifest)
+        release.write_to_fog { |f| sublog("Transferring #{f}") }
+
+        log("Update complete.")
+      end
+    end
+  end
+
+  private
+
+  def log(message)
+    puts ">> #{message}"
+  end
+
+  def sublog(message)
+    puts "   -- #{message}"
+  end
+
+  def error(message)
+    puts "!! #{message}"
+    exit 1
+  end
+
+  def configure_fog_client
+    error("No value provided for required options '--bucket'") unless options[:bucket]
+    credentials = {:provider => options[:provider]}
+    case credentials[:provider]
+    when 'AWS'
+      credentials[:aws_access_key_id] = options[:access_key_id]     if options[:access_key_id]
+      credentials[:aws_secret_access_key]  = options[:secret_access_key] if options[:secret_access_key]
+    when 'Rackspace'
+      credentials[:rackspace_username] = options[:access_key_id]     if options[:access_key_id]
+      credentials[:rackspace_api_key]  = options[:secret_access_key] if options[:secret_access_key]
+    else
+      error("Invalid provider.  Can be AWS or Rackspace")
+    end
+    Deb::Fog::Utils.fog         = Fog::Storage.new(credentials)
+    Deb::Fog::Utils.bucket      = Deb::Fog::Utils.fog.directories.new :key => options[:bucket]
+    Deb::Fog::Utils.bucket.reload
+    Deb::Fog::Utils.signing_key = options[:sign]
+    Deb::Fog::Utils.gpg_options = options[:gpg_options]
+    Deb::Fog::Utils.prefix      = options[:prefix]
+
+    # make sure we have a valid visibility setting
+    Deb::Fog::Utils.is_public =
+      case options[:visibility]
+      when "public"
+        true
+      when "private"
+        false
+      else
+        error("Invalid visibility setting given. Can be public or private")
+      end
+  end
+end

data/lib/deb/fog/manifest.rb

@@ -0,0 +1,121 @@
+require "tempfile"
+require "zlib"
+
+class Deb::Fog::Manifest
+  include Deb::Fog::Utils
+
+  attr_accessor :codename
+  attr_accessor :component
+  attr_accessor :architecture
+
+  attr_accessor :files
+
+  def initialize
+    @packages = []
+    @component = nil
+    @architecture = nil
+    @files = {}
+  end
+
+  class << self
+    def retrieve(codename, component, architecture)
+      m = if s = Deb::Fog::Utils.fog_read("dists/#{codename}/#{component}/binary-#{architecture}/Packages")
+        self.parse_packages(s)
+      else
+        self.new
+      end
+
+      m.codename = codename
+      m.component = component
+      m.architecture = architecture
+      m
+    end
+
+    def parse_packages(str)
+      m = self.new
+      str.split("\n\n").each do |s|
+        next if s.chomp.empty?
+        m.packages << Deb::Fog::Package.parse_string(s)
+      end
+      m
+    end
+  end
+
+  def packages
+    @packages
+  end
+
+  def add(pkg, preserve_versions)
+    if preserve_versions
+      @packages.delete_if { |p| p.name == pkg.name && p.version == pkg.version }
+    else
+      @packages.delete_if { |p| p.name == pkg.name }
+    end
+    @packages << pkg
+    pkg
+  end
+
+  def delete_package(pkg, versions=nil)
+    deleted = []
+    new_packages = @packages.select { |p|
+        # Include packages we didn't name
+        if p.name != pkg
+           p
+        # Also include the packages not matching a specified version
+        elsif (!versions.nil? and p.name == pkg and !versions.include? p.version)
+            p
+        end
+    }
+    deleted = @packages - new_packages
+    @packages = new_packages
+    deleted
+  end
+
+  def generate
+    @packages.collect { |pkg| pkg.generate }.join("\n")
+  end
+
+  def write_to_fog
+    manifest = self.generate
+
+    # store any packages that need to be stored
+    @packages.each do |pkg|
+      if pkg.needs_uploading?
+        yield pkg.url_filename if block_given?
+        fog_store(pkg.filename, pkg.url_filename, 'application/octet-stream; charset=binary')
+      end
+    end
+
+    # generate the Packages file
+    pkgs_temp = Tempfile.new("Packages")
+    pkgs_temp.write manifest
+    puts "package contents: #{manifest}!!!!! to dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages"
+    pkgs_temp.close
+    f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages"
+    yield f if block_given?
+    fog_store(pkgs_temp.path, f, 'text/plain; charset=us-ascii')
+    @files["#{@component}/binary-#{@architecture}/Packages"] = hashfile(pkgs_temp.path)
+    pkgs_temp.unlink
+
+    # generate the Packages.gz file
+    gztemp = Tempfile.new("Packages.gz")
+    gztemp.close
+    Zlib::GzipWriter.open(gztemp.path) { |gz| gz.write manifest }
+    f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages.gz"
+    yield f if block_given?
+    fog_store(gztemp.path, f, 'application/x-gzip; charset=binary')
+    @files["#{@component}/binary-#{@architecture}/Packages.gz"] = hashfile(gztemp.path)
+    gztemp.unlink
+
+    nil
+  end
+
+  def hashfile(path)
+    {
+      :size   => File.size(path),
+      :sha1   => Digest::SHA1.file(path).hexdigest,
+      :sha256 => Digest::SHA2.file(path).hexdigest,
+      :md5    => Digest::MD5.file(path).hexdigest
+    }
+  end
+end

data/lib/deb/fog/package.rb

@@ -0,0 +1,286 @@
+require "digest/sha1"
+require "digest/sha2"
+require "digest/md5"
+require "socket"
+require "tmpdir"
+
+class Deb::Fog::Package
+  include Deb::Fog::Utils
+
+  attr_accessor :name
+  attr_accessor :version
+  attr_accessor :epoch
+  attr_accessor :iteration
+  attr_accessor :maintainer
+  attr_accessor :vendor
+  attr_accessor :url
+  attr_accessor :category
+  attr_accessor :license
+  attr_accessor :architecture
+  attr_accessor :description
+
+  attr_accessor :dependencies
+  attr_accessor :provides
+  attr_accessor :conflicts
+  attr_accessor :replaces
+  attr_accessor :excludes
+
+
+  # Any other attributes specific to this package.
+  # This is where you'd put rpm, deb, or other specific attributes.
+  attr_accessor :attributes
+
+  # hashes
+  attr_accessor :url_filename
+  attr_accessor :sha1
+  attr_accessor :sha256
+  attr_accessor :md5
+  attr_accessor :size
+
+  attr_accessor :filename
+
+  class << self
+    include Deb::Fog::Utils
+
+    def parse_file(package)
+      p = self.new
+      p.extract_info(extract_control(package))
+      p.apply_file_info(package)
+      p.filename = package
+      p
+    end
+
+    def parse_string(s)
+      p = self.new
+      p.extract_info(s)
+      p
+    end
+
+    def extract_control(package)
+      if system("which dpkg &> /dev/null")
+        `dpkg -f #{package}`
+      else
+        # ar fails to find the control.tar.gz tarball within the .deb
+        # on Mac OS. Try using ar to list the control file, if found,
+        # use ar to extract, otherwise attempt with tar which works on OS X.
+        extract_control_tarball_cmd = "ar p #{package} control.tar.gz"
+
+        begin
+          safesystem("ar t #{package} control.tar.gz &> /dev/null")
+        rescue SafeSystemError
+          warn "Failed to find control data in .deb with ar, trying tar."
+          extract_control_tarball_cmd = "tar zxf #{package} --to-stdout control.tar.gz"
+        end
+
+        Dir.mktmpdir do |path|
+          safesystem("#{extract_control_tarball_cmd} | tar -zxf - -C #{path}")
+          File.read(File.join(path, "control"))
+        end
+      end
+    end
+  end
+
+  def initialize
+    @attributes = {}
+
+    # Reference
+    # http://www.debian.org/doc/manuals/maint-guide/first.en.html
+    # http://wiki.debian.org/DeveloperConfiguration
+    # https://github.com/jordansissel/fpm/issues/37
+    if ENV.include?("DEBEMAIL") and ENV.include?("DEBFULLNAME")
+      # Use DEBEMAIL and DEBFULLNAME as the default maintainer if available.
+      @maintainer = "#{ENV["DEBFULLNAME"]} <#{ENV["DEBEMAIL"]}>"
+    else
+      # TODO(sissel): Maybe support using 'git config' for a default as well?
+      # git config --get user.name, etc can be useful.
+      #
+      # Otherwise default to user@currenthost
+      @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
+    end
+
+    @name = nil
+    @architecture = "native"
+    @description = "no description given"
+    @version = nil
+    @epoch = nil
+    @iteration = nil
+    @url = nil
+    @category = "default"
+    @license = "unknown"
+    @vendor = "none"
+    @sha1 = nil
+    @sha256 = nil
+    @md5 = nil
+    @size = nil
+    @filename = nil
+    @url_filename = nil
+
+    @provides = []
+    @conflicts = []
+    @replaces = []
+    @dependencies = []
+
+    @needs_uploading = false
+  end
+
+  def filename=(f)
+    @filename = f
+    @needs_uploading = true
+    @filename
+  end
+
+  def url_filename
+    @url_filename || "pool/#{self.name[0]}/#{self.name[0..1]}/#{File.basename(self.filename)}"
+  end
+
+  def url_filename_encoded
+    @url_filename || "pool/#{self.name[0]}/#{self.name[0..1]}/#{fog_escape(File.basename(self.filename))}"
+  end
+
+  def needs_uploading?
+    @needs_uploading
+  end
+
+  def generate
+    template("package.erb").result(binding)
+  end
+
+  # from fpm
+  def parse_depends(data)
+    return [] if data.nil? or data.empty?
+    # parse dependencies. Debian dependencies come in one of two forms:
+    # * name
+    # * name (op version)
+    # They are all on one line, separated by ", "
+
+    dep_re = /^([^ ]+)(?: \(([>=<]+) ([^)]+)\))?$/
+    return data.split(/, */).collect do |dep|
+      m = dep_re.match(dep)
+      if m
+        name, op, version = m.captures
+        # this is the proper form of dependency
+        if op && version && op != "" && version != ""
+          "#{name} (#{op} #{version})".strip
+        else
+          name.strip
+        end
+      else
+        # Assume normal form dependency, "name op version".
+        dep
+      end
+    end
+  end # def parse_depends
+
+  # from fpm
+  def fix_dependency(dep)
+    # Deb dependencies are: NAME (OP VERSION), like "zsh (> 3.0)"
+    # Convert anything that looks like 'NAME OP VERSION' to this format.
+    if dep =~ /[\(,\|]/
+      # Don't "fix" ones that could appear well formed already.
+    else
+      # Convert ones that appear to be 'name op version'
+      name, op, version = dep.split(/ +/)
+      if !version.nil?
+        # Convert strings 'foo >= bar' to 'foo (>= bar)'
+        dep = "#{name} (#{debianize_op(op)} #{version})"
+      end
+    end
+
+    name_re = /^[^ \(]+/
+    name = dep[name_re]
+    if name =~ /[A-Z]/
+      dep = dep.gsub(name_re) { |n| n.downcase }
+    end
+
+    if dep.include?("_")
+      dep = dep.gsub("_", "-")
+    end
+
+    # Convert gem ~> X.Y.Z to '>= X.Y.Z' and << X.Y+1.0
+    if dep =~ /\(~>/
+      name, version = dep.gsub(/[()~>]/, "").split(/ +/)[0..1]
+      nextversion = version.split(".").collect { |v| v.to_i }
+      l = nextversion.length
+      nextversion[l-2] += 1
+      nextversion[l-1] = 0
+      nextversion = nextversion.join(".")
+      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
+    elsif (m = dep.match(/(\S+)\s+\(!= (.+)\)/))
+      # Append this to conflicts
+      self.conflicts += [dep.gsub(/!=/,"=")]
+      return []
+    elsif (m = dep.match(/(\S+)\s+\(= (.+)\)/)) and
+        self.attributes[:deb_ignore_iteration_in_dependencies?]
+      # Convert 'foo (= x)' to 'foo (>= x)' and 'foo (<< x+1)'
+      # but only when flag --ignore-iteration-in-dependencies is passed.
+      name, version = m[1..2]
+      nextversion = version.split('.').collect { |v| v.to_i }
+      nextversion[-1] += 1
+      nextversion = nextversion.join(".")
+      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
+    else
+      # otherwise the dep is probably fine
+      return dep.rstrip
+    end
+  end # def fix_dependency
+
+  # from fpm
+  def extract_info(control)
+    parse = lambda do |field|
+      value = control[/^#{field}: .*/]
+      if value.nil?
+        return nil
+      else
+        return value.split(": ",2).last
+      end
+    end
+
+    # Parse 'epoch:version-iteration' in the version string
+    version_re = /^(?:([0-9]+):)?(.+?)(?:-(.*))?$/
+    m = version_re.match(parse.call("Version"))
+    if !m
+      raise "Unsupported version string '#{parse.call("Version")}'"
+    end
+    self.epoch, self.version, self.iteration = m.captures
+
+    self.architecture = parse.call("Architecture")
+    self.category = parse.call("Section")
+    self.license = parse.call("License") || self.license
+    self.maintainer = parse.call("Maintainer")
+    self.name = parse.call("Package")
+    self.url = parse.call("Homepage")
+    self.vendor = parse.call("Vendor") || self.vendor
+    self.attributes[:deb_priority] = parse.call("Priority")
+    self.attributes[:deb_origin] = parse.call("Origin")
+    self.attributes[:deb_installed_size] = parse.call("Installed-Size")
+
+    # Packages manifest fields
+    self.url_filename = parse.call("Filename")
+    self.sha1 = parse.call("SHA1")
+    self.sha256 = parse.call("SHA256")
+    self.md5 = parse.call("MD5sum")
+    self.size = parse.call("Size")
+
+    # The description field is a special flower, parse it that way.
+    # The description is the first line as a normal Description field, but also continues
+    # on future lines indented by one space, until the end of the file. Blank
+    # lines are marked as ' .'
+    description = control[/^Description: .*[^\Z]/m]
+    description = description.gsub(/^[^(Description|\s)].*$/, "").split(": ", 2).last
+    self.description = description.gsub(/^ /, "").gsub(/^\.$/, "")
+
+    #self.config_files = config_files
+
+    self.dependencies += Array(parse_depends(parse.call("Depends")))
+    self.conflicts += Array(parse_depends(parse.call("Conflicts")))
+    self.provides += Array(parse_depends(parse.call("Provides")))
+    self.replaces += Array(parse_depends(parse.call("Replaces")))
+  end # def extract_info
+
+  def apply_file_info(file)
+    self.size = File.size(file)
+    self.sha1 = Digest::SHA1.file(file).hexdigest
+    self.sha256 = Digest::SHA2.file(file).hexdigest
+    self.md5 = Digest::MD5.file(file).hexdigest
+  end
+end

data/lib/deb/fog/release.rb

@@ -0,0 +1,139 @@
+require "tempfile"
+
+class Deb::Fog::Release
+  include Deb::Fog::Utils
+
+  attr_accessor :codename
+  attr_accessor :architectures
+  attr_accessor :components
+
+  attr_accessor :files
+  attr_accessor :policy
+
+  def initialize
+    @codename = nil
+    @architectures = []
+    @components = []
+    @files = {}
+    @policy = :public_read
+  end
+
+  class << self
+    def retrieve(codename)
+      if s = Deb::Fog::Utils.fog_read("dists/#{codename}/Release")
+        self.parse_release(s)
+      else
+        rel = self.new
+        rel.codename = codename
+        rel
+      end
+    end
+
+    def parse_release(str)
+      rel = self.new
+      rel.parse(str)
+      rel
+    end
+  end
+
+  def filename
+    "dists/#{@codename}/Release"
+  end
+
+  def parse(str)
+    parse = lambda do |field|
+      value = str[/^#{field}: .*/]
+      if value.nil?
+        return nil
+      else
+        return value.split(": ",2).last
+      end
+    end
+
+    # grab basic fields
+    self.codename = parse.call("Codename")
+    self.architectures = (parse.call("Architectures") || "").split(/\s+/)
+    self.components = (parse.call("Components") || "").split(/\s+/)
+
+    # find all the hashes
+    str.scan(/^\s+([^\s]+)\s+(\d+)\s+(.+)$/).each do |(hash,size,name)|
+      self.files[name] ||= { :size => size.to_i }
+      case hash.length
+      when 32
+        self.files[name][:md5] = hash
+      when 40
+        self.files[name][:sha1] = hash
+      when 64
+        self.files[name][:sha256] = hash
+      end
+    end
+  end
+
+  def generate
+    template("release.erb").result(binding)
+  end
+
+  def write_to_fog
+    # validate some other files are present
+    if block_given?
+      self.validate_others { |f| yield f }
+    else
+      self.validate_others
+    end
+
+    # generate the Release file
+    release_tmp = Tempfile.new("Release")
+    release_tmp.puts self.generate
+    release_tmp.close
+    yield self.filename if block_given?
+    fog_store(release_tmp.path, self.filename, 'text/plain; charset=us-ascii')
+
+    # sign the file, if necessary
+    if Deb::Fog::Utils.signing_key
+      key_param = Deb::Fog::Utils.signing_key != "" ? "--default-key=#{Deb::Fog::Utils.signing_key}" : ""
+      if system("gpg -a #{key_param} #{Deb::Fog::Utils.gpg_options} -b #{release_tmp.path}")
+        local_file = release_tmp.path+".asc"
+        remote_file = self.filename+".gpg"
+        yield remote_file if block_given?
+        raise "Unable to locate Release signature file" unless File.exists?(local_file)
+        fog_store(local_file, remote_file, 'application/pgp-signature; charset=us-ascii')
+        File.unlink(local_file)
+      else
+        raise "Signing the Release file failed."
+      end
+    else
+      # remove an existing Release.gpg, if it was there
+      fog_remove(self.filename+".gpg")
+    end
+
+    release_tmp.unlink
+  end
+
+  def update_manifest(manifest)
+    self.components << manifest.component unless self.components.include?(manifest.component)
+    self.architectures << manifest.architecture unless self.architectures.include?(manifest.architecture)
+    self.files.merge!(manifest.files)
+  end
+
+  def validate_others
+    to_apply = []
+    self.components.each do |comp|
+      %w(amd64 i386).each do |arch|
+        next if self.files.has_key?("#{comp}/binary-#{arch}/Packages")
+
+        m = Deb::Fog::Manifest.new
+        m.codename = self.codename
+        m.component = comp
+        m.architecture = arch
+        if block_given?
+          m.write_to_fog { |f| yield f }
+        else
+          m.write_to_fog
+        end
+        to_apply << m
+      end
+    end
+
+    to_apply.each { |m| self.update_manifest(m) }
+  end
+end

data/lib/deb/fog/templates/package.erb

@@ -0,0 +1,60 @@
+Package: <%= name %>
+Version: <%= "#{epoch}:" if epoch %><%= version %><%= "-" + iteration.to_s if iteration %>
+License: <%= license %>
+Vendor: <%= vendor %>
+Architecture: <%= architecture %>
+Maintainer: <%= maintainer  %>
+Installed-Size: <%= attributes[:deb_installed_size] %>
+<% if !dependencies.empty? and !attributes[:no_depends?] -%>
+Depends: <%= dependencies.collect { |d| fix_dependency(d) }.flatten.join(", ") %>
+<% end -%>
+<% if !conflicts.empty? -%>
+Conflicts: <%= conflicts.join(", ") %>
+<% end -%>
+<% if attributes[:deb_pre_depends] -%>
+Pre-Depends: <%= attributes[:deb_pre_depends].collect { |d| fix_dependency(d) }.flatten.join(", ") %>
+<% end -%>
+<% if !provides.empty? -%>
+<%# Turn each provides from 'foo = 123' to simply 'foo' because Debian :\ -%>
+<%#  http://www.debian.org/doc/debian-policy/ch-relationships.html -%>
+Provides: <%= provides.map {|p| p.split(" ").first}.join ", " %>
+<% end -%>
+<% if !replaces.empty? -%>
+Replaces: <%= replaces.join(", ") %>
+<% end -%>
+<% if attributes[:deb_recommends] -%>
+Recommends: <%= attributes[:deb_recommends].collect { |d| fix_dependency(d) }.flatten.join(", ") %>
+<% end -%>
+<% if attributes[:deb_suggests] -%>
+Suggests: <%= attributes[:deb_suggests].collect { |d| fix_dependency(d) }.flatten.join(", ") %>
+<% end -%>
+Section: <%= category %>
+<% if attributes[:deb_origin] -%>
+Origin: <%= attributes[:deb_origin] %>
+<% end -%>
+Priority: <%= attributes[:deb_priority] %>
+Homepage: <%= url or "http://nourlgiven.example.com/" %>
+Filename: <%= url_filename_encoded %>
+<% if size -%>
+Size: <%= size %>
+<% end -%>
+<% if sha1 -%>
+SHA1: <%= sha1 %>
+<% end -%>
+<% if sha256 -%>
+SHA256: <%= sha256 %>
+<% end -%>
+<% if md5 -%>
+MD5sum: <%= md5 %>
+<% end -%>
+<% lines = (description or "no description given").split("\n") -%>
+<% firstline, *remainder = lines -%>
+Description: <%= firstline %>
+<% if remainder.any? -%>
+<%= remainder.collect { |l| l =~ /^ *$/ ? " ." : " #{l}" }.join("\n") %>
+<% end -%>
+<% if attributes[:deb_field] -%>
+<%   attributes[:deb_field].each do |field, value| -%>
+<%= field %>: <%= value %>
+<%   end -%>
+<% end -%>

data/lib/deb/fog/templates/release.erb

@@ -0,0 +1,16 @@
+Codename: <%= codename %>
+Date: <%= Time.now.utc.strftime("%a, %d %b %Y %T %Z") %>
+Architectures: <%= architectures.join(" ") %>
+Components: <%= components.join(" ") %>
+MD5Sum:
+<% files.each do |f,p| -%>
+ <%= p[:md5] %> <%= p[:size].to_s.rjust(16) %> <%= f %>
+<% end -%>
+SHA1:
+<% files.each do |f,p| -%>
+ <%= p[:sha1] %> <%= p[:size].to_s.rjust(16) %> <%= f %>
+<% end -%>
+SHA256:
+<% files.each do |f,p| -%>
+ <%= p[:sha256] %> <%= p[:size].to_s.rjust(16) %> <%= f %>
+<% end -%>

data/lib/deb/fog/utils.rb

@@ -0,0 +1,88 @@
+require "base64"
+require "digest/md5"
+require "erb"
+require "tmpdir"
+
+module Deb::Fog::Utils
+  module_function
+  def fog; @fog end
+  def fog= v; @fog = v end
+  def bucket; @bucket end
+  def bucket= v; @bucket = v end
+  def is_public; @is_public end
+  def is_public= v; @is_public = v end
+  def signing_key; @signing_key end
+  def signing_key= v; @signing_key = v end
+  def gpg_options; @gpg_options end
+  def gpg_options= v; @gpg_options = v end
+  def prefix; @prefix end
+  def prefix= v; @prefix = v end
+
+  class SafeSystemError < RuntimeError; end
+
+  def safesystem(*args)
+    success = system(*args)
+    if !success
+      raise SafeSystemError, "'system(#{args.inspect})' failed with error code: #{$?.exitstatus}"
+    end
+    return success
+  end
+
+  def debianize_op(op)
+    # Operators in debian packaging are <<, <=, =, >= and >>
+    # So any operator like < or > must be replaced
+    {:< => "<<", :> => ">>"}[op.to_sym] or op
+  end
+
+  def template(path)
+    template_file = File.join(File.dirname(__FILE__), "templates", path)
+    template_code = File.read(template_file)
+    ERB.new(template_code, nil, "-")
+  end
+
+  def fog_path(path)
+    File.join(*[Deb::Fog::Utils.prefix, path].compact)
+  end
+
+  # from fog, Fog::AWS.escape
+  def fog_escape(string)
+    string.gsub(/([^a-zA-Z0-9_.\-~]+)/) {
+      "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
+    }
+  end
+
+  def fog_exists?(path)
+    return true if Deb::Fog::Utils.bucket.files.head(File.basename(path))
+    return false
+  end
+
+  def fog_read(path)
+    #puts "blerg: #{Deb::Fog::Utils.bucket.files}"
+    return nil unless fog_exists?(path)
+    Deb::Fog::Utils.bucket.files[fog_path(path)].read
+  end
+
+  def fog_store(path, filename=nil, content_type='application/octet-stream; charset=binary')
+    filename = File.basename(path) unless filename
+    obj = Deb::Fog::Utils.bucket.files.head(filename)
+    # check if the object already exists
+    unless obj.nil?
+      file_md5 = Digest::MD5.file(path)
+      # puts "#{filename} - #{file_md5} vs #{obj.etag.gsub('"', '')}"
+      return if file_md5.to_s == obj.etag.gsub('"', '')
+    end
+
+    # upload the file
+    file = Deb::Fog::Utils.bucket.files.create(
+      :key    => fog_path(filename),
+      :body   => File.open(path),
+      :public => Deb::Fog::Utils.is_public,
+      :content_type => content_type
+    )
+    # obj.write(Pathname.new(path), :acl => Deb::Fog::Utils.access_policy, :content_type => content_type)
+  end
+
+  def fog_remove(path)
+    Deb::Fog::Utils.bucket.files[fog_path(path)].destroy if fog_exists?(path)
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: deb-fog
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Czarkowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: Easily create and manage an APT repository with Fog.
+email: paul.czarkowski@rackspace.com
+executables:
+- deb-fog
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/deb-fog
+- lib/deb/fog/cli.rb
+- lib/deb/fog/manifest.rb
+- lib/deb/fog/package.rb
+- lib/deb/fog/release.rb
+- lib/deb/fog/templates/package.erb
+- lib/deb/fog/templates/release.erb
+- lib/deb/fog/utils.rb
+- lib/deb/fog.rb
+- README.md
+homepage: http://rackspace.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Easily create and manage an APT repository with Fog.
+test_files: []