bits-installer 0.1.0

data/lib/bits/bit_reader/local.rb

@@ -0,0 +1,13 @@
+require 'bits/bit_reader'
+
+module Bits
+  class BitReaderLocal < BitReader
+    def initialize(path)
+      @path = path
+    end
+
+    def read
+      File.new(@path).read
+    end
+  end
+end

data/lib/bits/bit_reader.rb

@@ -0,0 +1,7 @@
+module Bits
+  class BitReader
+    def read
+      raise 'not implemented: read'
+    end
+  end
+end

data/lib/bits/command.rb

@@ -0,0 +1,48 @@
+require 'optparse'
+
+module Bits
+  # Baseclass for commands.
+  class Command
+    attr_reader :ns
+
+    def setup(opts)
+      raise "not implemented: setup"
+    end
+
+    def initialize(ns)
+      @ns = ns
+    end
+  end
+
+  class << self
+    def commands
+      @commands ||= {}
+    end
+
+    def define_command(command_id, params={}, &block)
+      if commands[command_id]
+        raise "Command already defined: #{command_id}" 
+      end
+
+      desc = params[:desc] || "(no description)"
+
+      klass = Class.new(Command) do
+        @command_id = command_id
+        @name = command_id.to_s.capitalize
+        @desc = desc
+
+        class << self
+          attr_reader :command_id, :name, :desc
+
+          def to_s
+            "Bits::#{@name}"
+          end
+        end
+      end
+
+      klass.class_eval(&block)
+
+      commands[command_id] = klass
+    end
+  end
+end

data/lib/bits/command_provider.rb

@@ -0,0 +1,39 @@
+require 'bits/spawn'
+require 'json'
+
+module Bits
+  # Helper functions for writing providers which mainly interacts with external
+  # commands.
+  module CommandProvider
+    module ClassMethods
+      def check_command(command, name)
+        begin
+          exit_code = Bits.spawn command, :stdout => NULL
+        rescue Errno::ENOENT
+          log.debug "#{name} command not available"
+          return false
+        end
+
+        if exit_code != 0 then
+          log.debug "#{name} command could not be invoked"
+          return false
+        end
+
+        log.debug "#{name} command available"
+        true
+      end
+    end
+
+    def check_command(*args)
+      self.class.check_command(*args)
+    end
+
+    def run(*args)
+      self.class.run(*args)
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/bits/commands/install.rb

@@ -0,0 +1,75 @@
+require 'bits/command'
+require 'bits/logging'
+
+require 'highline'
+
+module Bits
+  define_command :install, :desc => 'Install a package' do
+    include Bits::Logging
+
+    def setup(opts)
+      ns[:force] = false
+      ns[:compiled] = nil
+
+      opts.banner = "Usage: bits install <bit>"
+      opts.on('--[no-]compiled', "Insist on installing an already compiled variant or not") do |v|
+        ns[:compiled] = v
+      end
+
+      opts.on('--force', "Insist on installing even if packages already installed") do |v|
+        ns[:force] = v
+      end
+    end
+
+    def entry(args)
+      if args.empty? then
+        puts parser.help
+        return 1
+      end
+
+      atom = args[0]
+
+      repository = ns[:repository]
+
+      parameters = {}
+      parameters[:compiled] = ns[:compiled] if ns.has_key? :compiled
+
+      p = repository.find_package atom, parameters
+
+      if p.installed? and not ns[:force]
+        log.info "Already installed '#{atom}' using provider(s): #{p.providers_s}"
+        return 0
+      end
+
+      matching = p.matching_ppps
+
+      raise "No matching PPP could be found" if matching.empty?
+
+      ppp = pick_one atom, matching
+
+      install_ppp atom, ppp
+      return 0
+    end
+
+    def pick_one(atom, matching)
+      return matching[0] if matching.size == 1
+
+      hl = HighLine.new $stdin
+
+      hl.choose do |menu|
+        menu.prompt = "Which provider would you like to install '#{atom}' with?"
+        matching.each do |match|
+          menu.choice(match.provider.provider_id) { match }
+        end
+      end
+    end
+
+    def install_ppp(atom, ppp)
+      provider = ppp.provider
+      package = ppp.package
+
+      log.info "Installing '#{atom}' using provider: #{provider.provider_id}"
+      provider.install package
+    end
+  end
+end

data/lib/bits/commands/remove.rb

@@ -0,0 +1,35 @@
+require 'bits/command'
+require 'bits/logging'
+
+module Bits
+  define_command :remove, :desc => "Remove a package" do
+    include Bits::Logging
+
+    def setup(opts)
+      opts.banner = "Usage: bits remove <bit>"
+    end
+
+    def entry(args)
+      if args.empty? then
+        puts parser.help
+        return 1
+      end
+
+      atom = args[0]
+
+      repository = @ns[:repository]
+
+      p = repository.find_package atom
+
+      unless p.installed?
+        log.info "Package not installed '#{atom}'"
+        return 0
+      end
+
+      log.info "Removing '#{atom}' using provider(s): #{p.providers_s}"
+
+      p.remove
+      return 0
+    end
+  end
+end

data/lib/bits/commands/show.rb

@@ -0,0 +1,49 @@
+require 'bits/command'
+require 'bits/logging'
+require 'bits/exceptions'
+
+module Bits
+  define_command :show, :desc => "Show a package" do
+    include Bits::Logging
+
+    def setup(opts)
+      opts.banner = "Usage: bits show <bit>"
+      opts.separator ""
+      opts.separator "Show information about the specified bit."
+    end
+
+    def entry(args)
+      if args.empty? then
+        puts parser.help
+        return 1
+      end
+
+      atom = args[0]
+
+      repository = ns[:repository]
+
+      criteria = {}
+      criteria[:compiled] = ns[:compiled] if ns.has_key? :compiled
+
+      begin
+        p = repository.find_package atom, criteria
+      rescue MissingBit
+        puts "No such atom '#{atom}'"
+        return 1
+      end
+
+      puts "PPPs:"
+
+      p.ppps.each do |ppp|
+        puts "  #{ppp.provider.provider_id}:"
+        puts "    Bit: #{ppp.bit.atom}"
+        puts "    Package Atom: #{ppp.package.atom}"
+        puts "    Installed: #{ppp.package.installed_s}"
+        puts "    Candidate: #{ppp.package.candidate_s}"
+        puts "    Parameters: #{ppp.parameters}"
+      end
+
+      return 0
+    end
+  end
+end

data/lib/bits/commands/sync.rb

@@ -0,0 +1,34 @@
+require 'bits/command'
+require 'bits/logging'
+require 'bits/exceptions'
+
+require 'fileutils'
+
+module Bits
+  define_command :sync, :desc => "sync local repository" do
+    include Bits::Logging
+
+    GIT = 'git'
+    CLONE_URL = 'https://github.com/udoprog/bits-repo'
+
+    def setup(opts)
+      opts.banner = "Usage: bits sync"
+      opts.separator ""
+      opts.separator "Sync local repository"
+    end
+
+    def entry(args)
+      dir = ns[:local_repository_dir]
+
+      setup_original dir unless File.directory? dir
+
+      Dir.chdir(dir) do
+        Bits.spawn [GIT, 'pull', 'origin', 'master']
+      end
+    end
+
+    def setup_original(dir)
+      Bits.spawn [GIT, 'clone', CLONE_URL, dir]
+    end
+  end
+end

data/lib/bits/exceptions.rb

@@ -0,0 +1,12 @@
+module Bits
+  class ProviderException < Exception; end
+
+  # Is raised when a package being requested does not exist.
+  class MissingPackage < ProviderException; end
+
+  # Is raised when a bit does not exist.
+  class MissingBit < ProviderException; end
+
+  # Is raised when a package being requested does not exist.
+  class MissingProvidedPackage < ProviderException; end
+end

data/lib/bits/execute_context.rb

@@ -0,0 +1,24 @@
+module Bits
+  class ExecuteContext
+    SUDO = 'sudo'
+
+    def initialize(user)
+      @user = user
+    end
+
+    def spawn(args, params={})
+      superuser = params[:superuser] || false
+
+      if superuser and not @user.superuser?
+        Bits.spawn [SUDO] + args, params
+      else
+        Bits.spawn args, params
+      end
+    end
+
+    def run(args, params={})
+      params[:ignore_exitcode] = true
+      spawn(args, params) == 0
+    end
+  end
+end

data/lib/bits/external_interface.rb

@@ -0,0 +1,204 @@
+require 'bits/logging'
+
+require 'rubygems'
+require 'json'
+
+module Bits
+  module ExternalInterface
+    class Interface
+      include Bits::Logging
+
+      attr_reader :capabilities
+
+      def initialize(id, args, stdin, stdout, pid)
+        @id = id
+        @args = args
+        @stdin = stdin
+        @stdout = stdout
+        @pid = pid
+        @capabilities = []
+      end
+
+      # end the child process by closing stdin.
+      def end
+        @stdin.close
+        Process.wait @pid
+        $?
+      end
+
+      def info(atom)
+        type, response = request :info, :atom => atom
+      end
+
+      def ping
+        begin
+          type, response = request :ping
+        rescue
+          log.debug "problem while pinging interface '#{@id}': #{$!}"
+          return nil
+        end
+
+        raise "Expected pong but got #{type}" unless type == :pong
+        @capabilities = (response['capabilities'] || []).map(&:to_sym)
+        return true
+      end
+
+      def request(type, command={})
+        command[:__type__] = type
+
+        write JSON.dump(command)
+        data = read
+
+        raise "empty response" if data.nil?
+
+        response = JSON.load(data)
+
+        response_type = response['__type__'].to_sym
+
+        if response_type == :error
+          error_text = response['text']
+          raise "Error in interface: #{error_text}"
+        end
+
+        [response_type, response]
+      end
+
+      def close
+        return if @stdin.nil? and @stdout.nil?
+        reap_child
+      end
+
+      private
+
+      def reap_child
+        @stdin.close unless @stdin.nil?
+        @stdout.close unless @stdout.nil?
+
+        @stdin = nil
+        @stdout = nil
+
+        # don't hang since write might have reaped it already.
+        Process.wait @pid, Process::WNOHANG
+      end
+
+      def write(data)
+        return if @stdin.nil?
+        @stdin.puts data
+        @stdin.flush
+      rescue
+        reap_child
+        raise
+      end
+
+      # read or no-op if it has been closed.
+      def read
+        return if @stdout.nil?
+        @stdout.gets
+      rescue
+        reap_child
+        raise
+      end
+    end
+
+    module ClassMethods
+      # access global interface cache for class methods.
+      def interfaces
+        ExternalInterface.interfaces
+      end
+
+      # Spawn an interface that is shared between all users.
+      def setup_interface(id, params = {})
+        capabilities = params[:capabilities] || []
+
+        interface = spawn_interface id
+
+        if interface.nil?
+          log.debug "Interface '#{id}' not available"
+          return false
+        end
+
+        missing_capabilities = capabilities - interface.capabilities
+
+        unless missing_capabilities.empty?
+          missing_s = missing_capabilities.join ', '
+          log.debug "Interface '#{id}' is available, but is missing capabilities: #{missing_s}"
+          return false
+        end
+
+        has_s = capabilities.join ', '
+        log.debug "Interface '#{id}' is available with capabilities: #{has_s}"
+        return true
+      end
+
+      private
+
+      def spawn_interface(id)
+        unless interfaces[id].nil?
+          return interfaces[id]
+        end
+
+        libexec_path = path_to_libexec "bits-#{id}"
+
+        command = [libexec_path]
+
+        stdout_r, stdout_w = IO.pipe
+        stdin_r, stdin_w = IO.pipe
+
+        pid = fork do
+          stdin_w.close
+          stdout_r.close
+
+          $stdin.reopen stdin_r
+          $stdout.reopen stdout_w
+
+          begin
+            exec(*command)
+          rescue Errno::ENOENT
+            $stdout.close
+            $stdin.close
+            exit ENOENT
+          end
+
+          exit 1
+        end
+
+        stdin_r.close
+        stdout_w.close
+
+        interface = Interface.new(id, command, stdin_w, stdout_r, pid)
+
+        if not interface.ping
+          interface.close
+          return nil
+        end
+
+        interfaces[id] = interface
+      end
+
+      def path_to_libexec(name)
+        File.join File.dirname(File.expand_path(__FILE__)), File.join('..', 'libexec', name)
+      end
+    end
+
+    # global cache for interfaces.
+    def self.interfaces
+      @interfaces ||= {}
+    end
+
+    # access global interface cache for instances.
+    def interfaces
+      self.class.interfaces
+    end
+
+    # close all global interfaces
+    def self.close_interfaces
+      interfaces.each do |id, interface|
+        interface.close
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end