aptly 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d28012fc713f236f2439309dddc1d30fdb66338e
+  data.tar.gz: ee1285d3545517e13dd2dff95b3222b8a081babf
+SHA512:
+  metadata.gz: 4d9e6934ea4a9b23b2c3028110d39b8bcbcd7e07dc25132e47854d2bdb570961e32e514147759dd7f5274c28f85ff6f041663960e405479329e5cf2960fb5953
+  data.tar.gz: 3b39146ff8e28f1af97c602c4415a48948a666c6a66d5660aa7d2fbc170f29812af166613188b19e180c3ad5a42d930d61496112b037b6132ef1a9349e4478f1

data/lib/aptly.rb

@@ -0,0 +1,102 @@
+require 'aptly/version'
+require 'aptly/mutex'
+require 'aptly/error'
+require 'aptly/mirror'
+require 'aptly/repo'
+require 'aptly/snapshot'
+require 'aptly/publish'
+require 'aptly/string'
+require 'aptly/hash'
+
+module Aptly
+
+  # runcmd handles running arbitrary commands. It is intended to run aptly-
+  # specific commands, and as such, it uses a mutex to take gurantee
+  # consistency and avoid multiple processes modifying aptly simultaneously.
+  #
+  # == Parameters:
+  # cmd::
+  #   A string holding the command to run
+  #
+  # == Returns:
+  # The content of stdout
+  #
+  def runcmd cmd
+    Mutex.lock
+    at_exit { Mutex.unlock }
+
+    out = %x(#{cmd} 2>&1)
+    res = $?.exitstatus
+
+    Mutex.unlock
+
+    if res != 0
+      raise AptlyError.new "aptly: command failed: #{cmd}", out
+    end
+
+    return out
+  end
+
+  # Parses the output lines of aptly listing commands
+  #
+  # == Parameters:
+  # lines::
+  #   An array of lines of string output from aptly list commands
+  #
+  # == Returns:
+  # An array of items
+  #
+  def parse_list lines
+    items = Array.new
+    lines.each do |line|
+      if line.start_with?(' * ')
+        parts = line.split(/\[|\]/, 3)
+        items << parts[1] if parts.length == 3
+      end
+    end
+    items
+  end
+
+  # Parses the output of aptly show commands.
+  #
+  # == Parameters:
+  # lines::
+  #   An array of strings of aptly output
+  #
+  # == Returns:
+  # A hash of information
+  #
+  def parse_info lines
+    items = Hash.new
+    lines.reject{|l| l.empty?}.each do |line|
+      parts = line.split(/:\s/, 2)
+      items[parts[0]] = parts[1].strip if parts.length == 2
+    end
+
+    def multi items, key
+      items[key] = items[key].split(' ') if items.has_key? key
+    end
+
+    multi items, 'Components'
+    multi items, 'Architectures'
+
+    items
+  end
+
+  # Parses aptly output of double-space indented lists
+  #
+  # == Parameters:
+  # lines::
+  #   Output lines from an aptly list command
+  #
+  # == Result:
+  # An array of items
+  #
+  def parse_indented_list lines
+    items = Array.new
+    lines.each do |line|
+      items << line.strip if line.start_with? '  '
+    end
+    items
+  end
+end

data/lib/aptly/error.rb

@@ -0,0 +1,9 @@
+class AptlyError < RuntimeError
+  attr_accessor :output
+  @output = nil
+
+  def initialize msg=nil, output=nil
+    @output = output
+    super msg
+  end
+end

data/lib/aptly/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def arg arg, default
+    if self.has_key? arg
+      return self[arg]
+    else
+      return default
+    end
+  end
+end

data/lib/aptly/mirror.rb

@@ -0,0 +1,150 @@
+module Aptly
+  extend self
+
+  # Creates a new mirror in aptly. This simply creates the necessary records in
+  # leveldb and doesn't do any heavy lifting.
+  #
+  # == Parameters:
+  # name::
+  #   The name of the new repository
+  # baseurl::
+  #   The URL to the repository content
+  # dist::
+  #   The distribution (e.g. precise, quantal)
+  # components::
+  #   The repository components (e.g. main, stable)
+  # archlist::
+  #   A list of architecture types to mirror
+  # ignoresigs::
+  #   Ignore package signature mismatches
+  # source::
+  #   Optionally mirror in source packages
+  #
+  # == Returns:
+  # An Aptly::Mirror object
+  #
+  def create_mirror(
+    name,
+    baseurl,
+    dist,
+    kwargs={}
+  )
+    components = kwargs.arg :components, []
+    archlist = kwargs.arg :archlist, []
+    ignoresigs = kwargs.arg :ignoresigs, false
+    source = kwargs.arg :source, false
+
+    if list_mirrors.include? name
+      raise AptlyError.new "Mirror '#{name}' already exists"
+    end
+
+    if components.length < 1
+      raise AptlyError.new "1 or more components are required"
+    end
+
+    cmd = 'aptly mirror create'
+    cmd += " -architectures #{archlist.join(',')}" if !archlist.empty?
+    cmd += ' -ignore-signatures' if ignoresigs
+    cmd += ' -with-sources' if source
+    cmd += " #{name.quote} #{baseurl.quote} #{dist.quote}"
+    cmd += " #{components.join(' ')}"
+
+    runcmd cmd
+    return Mirror.new name
+  end
+
+  # Returns a list of existing mirrors in aptly
+  #
+  # == Returns
+  # An array of mirror names
+  #
+  def list_mirrors
+    out = runcmd 'aptly mirror list'
+    parse_list out.lines
+  end
+
+  # Retrieves information about a mirror
+  #
+  # == Parameters:
+  # name::
+  #   The name of the mirror to retrieve info for
+  #
+  # == Returns:
+  # A hash of mirror information
+  #
+  def mirror_info name
+    out = runcmd "aptly mirror show #{name.quote}"
+    parse_info out.lines
+  end
+
+  class Mirror
+    attr_accessor :name, :baseurl, :dist, :components, :archlist
+
+    @name = ''
+    @baseurl = ''
+    @dist = ''
+    @components = []
+    @archlist = []
+
+    # Instantiates a new Mirror object
+    #
+    # == Parameters:
+    # name::
+    #   Then name associated with the mirror
+    #
+    def initialize name
+      if !Aptly::list_mirrors.include? name
+        raise AptlyError.new("Mirror '#{name}' does not exist")
+      end
+
+      info = Aptly::mirror_info name
+      @name = info['Name']
+      @baseurl = info['Archive Root URL']
+      @dist = info['Distribution']
+      @components = info['Components']
+      @archlist = info['Architectures']
+    end
+
+    # Drops an existing mirror from aptly's configuration
+    def drop
+      Aptly::runcmd "aptly mirror drop #{@name.quote}"
+    end
+
+    # List all packages contained in a mirror
+    #
+    # == Returns:
+    # An array of packages
+    #
+    def list_packages
+      res = []
+      out = Aptly::runcmd "aptly mirror show -with-packages #{@name.quote}"
+      Aptly::parse_indented_list out.lines
+    end
+
+    # Shortcut method to snapshot an Aptly::Mirror object
+    def snapshot name
+      Aptly::create_mirror_snapshot name, @name
+    end
+
+    # Updates a repository, syncing in all packages which have not already been
+    # downloaded and caches them locally.
+    #
+    # == Parameters:
+    # ignore_cksum::
+    #   Ignore checksum mismatches
+    # ignore_sigs::
+    #   Ignore author signature mismatches
+    #
+    def update kwargs={}
+      ignore_cksum = kwargs.arg :ignore_cksum, false
+      ignore_sigs = kwargs.arg :ignore_sigs, false
+
+      cmd = 'aptly mirror update'
+      cmd += ' -ignore-checksums' if ignore_cksum
+      cmd += ' -ignore-signatures' if ignore_sigs
+      cmd += " #{@name.quote}"
+
+      Aptly::runcmd cmd
+    end
+  end
+end

data/lib/aptly/mutex.rb

@@ -0,0 +1,78 @@
+module Aptly
+  extend self
+
+  class Mutex
+    @@mutex_path = '/tmp/aptly.lock'
+
+    # Static attribute accessor for mutex path
+    #
+    # == Returns:
+    # The path to the aptly mutex file
+    #
+    def self.mutex_path
+      @@mutex_path
+    end
+
+    # Alter the mutex path. This should be set to the same path in all places
+    # where ruby-aptly will be used on the same host, since the mutex is meant
+    # to be system-wide.
+    #
+    # == Parameters:
+    # path::
+    #   The desired path for the mutex
+    #
+    def self.mutex_path= path
+      @@mutex_path = path
+    end
+
+    # Attempts to acquire the aptly mutex. This method will wait if the mutex
+    # is already locked elsewhere, and check back every 5 seconds to see if it
+    # has been freed. On each check where the mutex is determined to be in use,
+    # we check if the process which originally acquired the lock is still
+    # running so we can acquire a stale mutex should we need to.
+    #
+    # == Returns:
+    # True, once the lock is acquired.
+    #
+    def self.lock
+      while self.locked?
+        self.running? && sleep(5) || self.unlock
+      end
+      File.open(@@mutex_path, 'w') {|f| f.write Process.pid}
+    end
+
+    # Checks if the mutex is in use. This is done via a simple file check.
+    #
+    # == Returns:
+    # True if locked, else false
+    #
+    def self.locked?
+      File.exist? @@mutex_path
+    end
+
+    # Checks if the process which originally acquired the mutex is still
+    # running. This is useful to determine staleness of a locked mutex.
+    #
+    # == Returns:
+    # True if running, else false
+    #
+    def self.running?
+      begin
+        pid = File.open(@@mutex_path).read.to_i
+        Process.kill(0, pid)
+        return true
+      rescue Errno::ESRCH, Errno::ENOENT
+        return false
+      end
+    end
+
+    # Unlocks the mutex so that other processes may acquire it.
+    #
+    # == Returns:
+    # True if unlock happens, else false
+    #
+    def self.unlock
+      File.delete @@mutex_path if self.locked?
+    end
+  end
+end

data/lib/aptly/publish.rb

@@ -0,0 +1,147 @@
+module Aptly
+  extend self
+
+  # Publish a snapshot or repo resource.
+  #
+  # == Parameters:
+  # type::
+  #   The type of resource to publish. 'snapshot' and 'repo' supported.
+  # name::
+  #   The name of the resource to publish.
+  # prefix::
+  #   An optional prefix to publish to.
+  # component::
+  #   The component to publish to. If empty, aptly will attempt to guess
+  #   from the source, or use 'main' as the default.
+  # dist::
+  #   The distribution name. If empty, aptly will try to guess.
+  # gpg_key::
+  #   The gpg key to sign the repository. Uses default if not specified.
+  # keyring::
+  #   GPG keyring to use
+  # label::
+  #   An optional label to give the published resource
+  # origin::
+  #   The value of the 'Origin' field
+  # secret_keyring::
+  #   GPG secret keyring to use
+  # sign::
+  #   When false, don't sign Release files. Defaults to true.
+  #
+  def publish(
+    type,
+    name,
+    kwargs={}
+  )
+    prefix = kwargs.arg :prefix, ''
+    component = kwargs.arg :component, ''
+    dist = kwargs.arg :dist, ''
+    gpg_key = kwargs.arg :gpg_key, ''
+    keyring = kwargs.arg :keyring, ''
+    label = kwargs.arg :label, ''
+    origin = kwargs.arg :origin, ''
+    secret_keyring = kwargs.arg :secret_keyring, ''
+    sign = kwargs.arg :sign, true
+
+    if type != 'repo' && type != 'snapshot'
+      raise AptlyError "Invalid publish type: #{type}"
+    end
+
+    cmd = "aptly publish #{type}"
+    cmd += ' -skip-signing' if !sign
+    cmd += " -component #{component.quote}" if !component.empty?
+    cmd += " -distribution #{dist.quote}" if !dist.empty?
+    cmd += " -gpg-key #{gpg_key.quote}" if !gpg_key.empty?
+    cmd += " -keyring #{keyring.quote}" if !keyring.empty?
+    cmd += " -label #{label.quote}" if !label.empty?
+    cmd += " -origin #{origin.quote}" if !origin.empty?
+    cmd += " #{name.quote}"
+    cmd += " #{prefix.quote}" if !prefix.empty?
+    if !secret_keyring.empty?
+      cmd += " -secret-keyring #{secret_keyring.quote}"
+    end
+
+    runcmd cmd
+  end
+
+  # List existing published resources.
+  #
+  # == Returns
+  # A hash of published resource information. The outer hash key is the
+  # published resource path, and its value is the resource metadata.
+  #
+  def list_published
+    res = Hash.new
+    out = runcmd 'aptly publish list'
+    out.lines.each do |line|
+      if line.start_with? '  * '
+        resource = {}
+        parts = line[3..-1].split(/\[|\]|\(|\)/)
+        resource['path'] = parts[0].strip
+        resource['component'] = parts[1].strip
+        resource['archlist'] = parts[3].split(', ')
+        resource['from_name'] = parts[5].strip
+        if parts[6].include? 'Snapshot'
+          resource['from_type'] = 'snapshot'
+        elsif parts[6].include? 'Repo'
+          resource['from_type'] = 'repo'
+        else
+          next
+        end
+        dist = line.split.last
+        res[dist] = resource
+      end
+    end
+    res
+  end
+
+  class PublishedResource
+    attr_accessor :path, :from_name, :from_type, :component
+    attr_accessor :archlist, :dist
+
+    @path = ''
+    @from_name = ''
+    @from_type = ''
+    @component = ''
+    @archlist = []
+    @dist = ''
+
+    # Instantiates a new published resource object from an existing published
+    # resource.
+    #
+    # == Parameters:
+    # dist::
+    #   The distribution name
+    # prefix::
+    #   An optional prefix
+    #
+    # == Returns:
+    # An Aptly::PublishedResource object
+    #
+    def initialize dist, prefix=''
+      idx = "#{prefix}#{prefix.empty? ? '' : '/'}#{dist}"
+
+      published = Aptly::list_published
+      if !published.include? idx
+        raise AptlyError.new "Published resource #{idx} does not exist"
+      end
+
+      @dist = dist
+      @prefix = prefix
+      @path = published[idx]['path']
+      @from_name = published[idx]['from_name']
+      @from_type = published[idx]['from_type']
+      @component = published[idx]['component']
+      @archlist = published[idx]['archlist']
+    end
+
+    # Unpublish a currently published resource.
+    def drop
+      cmd = 'aptly publish drop'
+      cmd += " #{@dist.quote}"
+      cmd += " #{@prefix.quote}" if !@prefix.empty?
+
+      Aptly::runcmd cmd
+    end
+  end
+end