bits-installer 0.1.0

data/lib/bits/provider_reporting.rb

@@ -0,0 +1,24 @@
+module Bits
+  # Used to provide a neat class based interface for reporting the last check
+  # error.
+  module ProviderReporting
+    module ClassMethods
+      def check_errors
+        @check_errors ||= []
+      end
+
+      def last_check_error
+        check_errors[-1]
+      end
+
+      def check_error(text)
+        check_errors << text
+        log.debug("Error on check: #{text}")
+      end
+    end
+
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+  end
+end

data/lib/bits/repository.rb

@@ -0,0 +1,118 @@
+require 'bits/logging'
+require 'bits/bit_declaration'
+require 'bits/bit'
+require 'bits/package_proxy'
+require 'bits/exceptions'
+
+module Bits
+  class PPP
+    attr_accessor :bit, :provider, :package, :parameters, :path
+
+    def initialize(bit, provider, package, parameters, path)
+      @bit = bit
+      @provider = provider
+      @package = package
+      @parameters = parameters
+      @path = path
+    end
+  end
+
+  class Repository
+    include Bits::Logging
+
+    attr_accessor :providers, :backend
+
+    def initialize(providers, backend)
+      @bitcache = {}
+      @providers = providers
+      @backend = backend
+    end
+
+    def find_package(atom, criteria={})
+      ppps = []
+
+      iterate_packages(atom) do |bit, atom, provider, parameters, path|
+        begin
+          package = provider.query(atom)
+        rescue MissingPackage
+          log.warn "No such atom '#{atom}' for provider '#{provider.provider_id}'"
+          next
+        end
+
+        ppps << PPP.new(bit, provider, package, parameters, path)
+      end
+
+      if ppps.empty?
+        raise MissingProvidedPackage.new atom
+      end
+
+      return PackageProxy.new ppps, criteria
+    end
+
+    private
+
+    def load_bit(atom)
+      log.debug "Loading bit: #{atom}"
+      return @bitcache[atom] unless @bitcache[atom].nil?
+      reader = backend.fetch(atom)
+      @bitcache[atom] = Bit.eval reader, atom
+    end
+
+    def iterate_packages(atom)
+      references = [[[], atom, nil]]
+
+      while not references.empty?
+        path, atom, filter = references.shift
+
+        if path.include? atom
+          raise "Circular reference: #{path.inspect.join ' -> '}"
+        end
+
+        current_bit = load_bit atom
+
+        path << current_bit.atom
+
+        # match all the providers that is specified by the bit and if
+        # provider_filter is defined, explicitly match that too.
+        matching = providers.select do |p|
+          current_bit.has_provider?(p.provider_id) and
+          (filter.nil? or filter == p.provider_id)
+        end
+
+        raise "No matching providers: #{current_bit}" if matching.empty?
+
+        # for each matching provider, find the data associated with this
+        # provider and bit.
+        matching.each do |provider|
+          provider_data = current_bit.get_provider_data provider.provider_id
+
+          if provider_data.kind_of? BitReference
+            references << [
+              Array.new(path),
+              provider_data.atom,
+              # only match for this specified provider.
+              provider.provider_id
+            ]
+
+            next
+          end
+
+          if provider_data.kind_of? BitParameters
+            params = provider_data.parameters
+
+            atom = (params[:atom] || current_bit.atom)
+
+            params = {
+              :compiled => (params[:compiled] || false),
+            }
+
+            yield [current_bit, atom, provider, params, path]
+            next
+          end
+
+          raise "Unknown provider data '#{data}'"
+        end
+      end
+    end
+  end
+end

data/lib/bits/spawn.rb

@@ -0,0 +1,89 @@
+require 'bits/logging'
+
+module Bits
+  ENOENT = 0x7f
+  PIPE = 0x01
+  NULL = 0x02
+
+  DEV_NULL = '/dev/null'
+
+  class << self
+    def handle_exit(pid, fd_cache, ignore_exitcode)
+      fd_cache.each do |key, fd|
+        fd.close
+      end
+
+      Process.waitpid pid
+
+      exitstatus = $?.exitstatus
+
+      if exitstatus == ENOENT then
+        raise Errno::ENOENT
+      end
+
+      if not ignore_exitcode and exitstatus != 0 then
+        raise "Bad exit status: #{exitstatus}"
+      end
+
+      exitstatus
+    end
+
+    def setup_file(type, global, fd_cache)
+      case type
+        when PIPE then IO.pipe
+        when NULL then (fd_cache[:null] ||= File.open(DEV_NULL, 'w'))
+        else type
+      end
+    end
+
+    def handle_child_file(type, global, fds)
+      case type
+      when PIPE then
+        fds[0].close
+        global.reopen fds[1]
+      else
+        global.reopen fds unless fds === global
+      end
+    end
+
+    def handle_parent_file(type, fds)
+      case type
+      when PIPE then
+        fds[1].close
+        fds[0]
+      else fds
+      end
+    end
+
+    def spawn(args, params={})
+      fd_cache = {}
+
+      stdout = (params[:stdout] || $stdout)
+      stderr = (params[:stderr] || $stderr)
+      ignore_exitcode = params[:ignore_exitcode] || false
+
+      out = setup_file stdout, $stdout, fd_cache
+      err = setup_file stderr, $stderr, fd_cache
+
+      pid = fork do
+        handle_child_file stdout, $stdout, out
+        handle_child_file stderr, $stderr, err
+
+        begin
+          exec(*args)
+        rescue Errno::ENOENT
+          exit ENOENT
+        rescue
+          exit 1
+        end
+      end
+
+      out = handle_parent_file stdout, out
+      err = handle_parent_file stderr, err
+
+      return handle_exit pid, fd_cache, ignore_exitcode unless block_given?
+      yield [out, err]
+      handle_exit pid, fd_cache, ignore_exitcode
+    end
+  end
+end

data/lib/bits/user.rb

@@ -0,0 +1,27 @@
+module Bits
+  class User
+    def superuser?
+      raise "not implemented: superuser?"
+    end
+  end
+
+  class PosixUser < User
+    def superuser?
+      Process.uid == 0
+    end
+  end
+
+  def self.setup_user
+    if RUBY_PLATFORM.include? 'darwin'
+      kind = PosixUser
+    elsif RUBY_PLATFORM.include? 'linux'
+      kind = PosixUser
+    elsif RUBY_PLATFORM.include? 'win32'
+      kind = Win32User
+    else
+      raise "Unsupported platform: #{RUBY_PLATFORM}"
+    end
+
+    kind.new
+  end
+end

data/lib/bits/version.rb

@@ -0,0 +1,3 @@
+module Bits
+  VERSION = '0.1.0'
+end

data/lib/bits.rb

@@ -0,0 +1,156 @@
+require 'optparse'
+
+require 'bits/backend/local'
+require 'bits/backend/join'
+require 'bits/package'
+require 'bits/repository'
+
+require 'bits/commands/install'
+require 'bits/commands/remove'
+require 'bits/commands/show'
+require 'bits/commands/sync'
+
+require 'bits/provider/python'
+require 'bits/provider/apt'
+require 'bits/provider/portage'
+require 'bits/provider/homebrew'
+
+require 'bits/external_interface'
+require 'bits/user'
+
+module Bits
+  class << self
+    def parse_options(args)
+      ns = {}
+
+      subcommands = Hash.new
+      available_providers = Array.new
+      unavailable_providers = Array.new
+
+      global = OptionParser.new do |global_opts|
+        global_opts.banner = "Usage: bits <command> [options]"
+
+        global_opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          ns[:verbose] = v
+        end
+
+        global_opts.on("-d", "--debug", "Enable debug logging") do |v|
+          @log.level = Log4r::DEBUG
+        end
+
+        global_opts.separator ""
+        global_opts.separator "Available commands:"
+
+        Bits.commands.values.sort_by{|c| c.command_id.to_s}.each do |klass|
+          global_opts.separator "  #{klass.command_id}: #{klass.desc}"
+          subcommands[klass.command_id] = klass
+        end
+
+        Bits.providers.values.sort_by{|p| p.provider_id.to_s}.each do |provider_class|
+          if provider_class.check
+            available_providers << provider_class
+          else
+            unavailable_providers << provider_class
+          end
+        end
+
+        global_opts.separator "Providers:"
+
+        available_providers.each do |provider_class|
+          global_opts.separator "  #{provider_class.provider_id}: #{provider_class.desc}"
+        end
+
+        global_opts.separator "Unavailable providers:"
+        unavailable_providers.each do |klass|
+          global_opts.separator "  #{klass.provider_id}: #{klass.last_check_error}"
+        end
+      end
+
+      global.order!
+      command = ARGV.shift
+
+      if command.nil? then
+        $stderr.puts global.help
+        exit 0
+      end
+
+      command = command.to_sym
+
+      if subcommands[command].nil? then
+        $stderr.puts "No such command: #{command}"
+        $stderr.puts global.help
+        exit 0
+      end
+
+      command_klass = subcommands[command]
+      command = command_klass.new ns
+
+      command_parser = OptionParser.new do |opts|
+        command.setup opts
+      end
+
+      command_parser.order!
+
+      ns[:user] = setup_user
+      ns[:local_repository_dir] = setup_local_repository_dir ns
+
+      command = command_klass.new ns
+      providers = setup_providers available_providers, ns
+      backend = setup_backend ns
+
+      ns[:repository] = Bits::Repository.new(providers, backend)
+
+      return ARGV, command
+    end
+
+    # Setup the path to the local repository directory.
+    def setup_local_repository_dir(ns)
+      home = ENV['HOME']
+      raise "HOME environment variable not defined" if home.nil?
+      File.join home, '.bits'
+    end
+
+    def setup_logging
+      log = Log4r::Logger.new 'Bits'
+      log.outputters << Log4r::Outputter.stdout
+      log.level =  Log4r::INFO
+      log
+    end
+
+    def setup_providers(available_providers, ns)
+      available_providers.collect do |provider_class|
+        provider_class.new ns
+      end
+    end
+
+    def setup_backend(ns)
+      cwd_dir = File.join Dir.pwd, 'bits'
+      local_dir = ns[:local_repository_dir]
+
+      backends = Array.new
+
+      backends << LocalBackend.new(cwd_dir) if File.directory? cwd_dir
+      backends << LocalBackend.new(local_dir) if File.directory? local_dir
+
+      JoinBackend.new backends
+    end
+
+    def main(args)
+      @log = setup_logging
+
+      args, command = parse_options(args)
+
+      begin
+        command.entry args
+      ensure
+        Bits::ExternalInterface.close_interfaces
+      end
+
+      return 0
+    end
+  end
+end
+
+if __FILE__ == $0
+    exit Bits::main(ARGV)
+end

data/lib/libexec/bits-python

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+
+import sys
+import json
+
+try:
+    import pkg_resources
+    has_pkg_resources = True
+except ImportError:
+    has_pkg_resources = False
+
+try:
+    import portage
+    has_portage = True
+except ImportError:
+    has_portage = False
+
+
+class RequestError(Exception):
+    pass
+
+
+class MissingRequestKey(Exception):
+    def __init__(self, key):
+        super(MissingRequestKey, self).__init__(
+            "Missing key '{0}' in request".format(key))
+
+
+def ping_handler(args):
+    capabilities = list()
+
+    if has_portage:
+        capabilities.append("portage")
+
+    if has_pkg_resources:
+        capabilities.append("pkg_resources")
+
+    return {
+        "__type__": "pong",
+        "capabilities": capabilities
+    }
+
+
+def find_project(package):
+    for p in pkg_resources.working_set:
+        if p.project_name == package:
+            return p
+
+    return None
+
+
+def python_info_handler(request):
+    atom = request.get('atom')
+
+    if atom is None:
+        raise MissingRequestKey("atom")
+
+    project = find_project(atom)
+
+    if project is None:
+        return {
+            "__type__": "missing_atom",
+            "atom": atom,
+        }
+
+    return {
+        "__type__": "info",
+        "name": project.project_name,
+        "installed": project.version,
+    }
+
+
+def portage_info_handler(request):
+    package = request['package']
+
+    if package is None:
+        raise MissingRequestKey("package")
+
+    vartree = portage.db[portage.root]['vartree']
+    porttree = portage.db[portage.root]['porttree']
+
+    name = None
+    installed = vartree.dep_bestmatch(package)
+    candidate = porttree.dep_bestmatch(package)
+
+    if not installed:
+        installed = None
+    else:
+        _, installed, rev = portage.pkgsplit(installed)
+        installed = "{0}-{1}".format(installed, rev)
+
+    if not candidate:
+        candidate = None
+    else:
+        name, candidate, rev = portage.pkgsplit(candidate)
+        candidate = "{0}-{1}".format(candidate, rev)
+
+    return {
+        "__type__": "info",
+        "name": name,
+        "installed": installed,
+        "candidate": candidate,
+    }
+
+
+handlers = {
+    "ping": ping_handler,
+    "python_info": python_info_handler,
+    "portage_info": portage_info_handler,
+}
+
+
+def handle_request(line):
+    try:
+        request = json.loads(line)
+    except:
+        raise RequestError("Could not decode request, expected type: json")
+
+    request_type = request.get('__type__')
+
+    if request_type is None:
+        raise RequestError("Missing 'type' in request")
+
+    handler = handlers.get(request_type)
+
+    if handler is None:
+        raise RequestError("No handler for type '{0}'".format(request_type))
+
+    return handler(request)
+
+
+def guarded_handle_request(line):
+    try:
+        return handle_request(line)
+    except RequestError, e:
+        return {"__type__": "error", "text": str(e)}
+
+
+def main(args):
+    while True:
+        try:
+            line = sys.stdin.readline()
+        except KeyboardInterrupt:
+            break
+
+        if not line:
+            break
+
+        response = guarded_handle_request(line)
+        print >>sys.stdout, json.dumps(response)
+        sys.stdout.flush()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))