bits-installer 0.1.1 → 0.3.0

data/lib/bits/provider/portage.rb

@@ -4,6 +4,7 @@ require 'bits/command_provider'
 require 'bits/package'
 require 'bits/logging'
 require 'bits/spawn'
+require 'bits/external_interface'
 
 require 'json'
 
@@ -34,8 +35,7 @@ module Bits
       true
     end
 
-    def initialize(ns)
-      super ns
+    def setup
       @client = interfaces[:python]
     end
 

data/lib/bits/provider/python.rb

@@ -5,6 +5,7 @@ require 'bits/spawn'
 require 'bits/package'
 require 'bits/logging'
 require 'bits/exceptions'
+require 'bits/cache'
 
 require 'bits/external_interface'
 
@@ -18,6 +19,7 @@ module Bits
     include Bits::CommandProvider
     include Bits::ExternalInterface
     include Bits::ProviderReporting
+    include Bits::Cache
 
     PIP = 'pip'
     INDEX = 'https://pypi.python.org/pypi'
@@ -37,34 +39,38 @@ module Bits
       true
     end
 
-    def initialize(ns)
-      super ns
+    def setup
       @client = XMLRPC::Client.new_from_uri(INDEX)
       @client.http_header_extra = {'Content-Type' => 'text/xml'}
       @python = self.class.interfaces[:python]
+      @cache = setup_cache ns[:bits_dir], provider_id
     end
 
-    def get_installed_version(package_atom)
-      type, response = @python.request :python_info, :atom => package_atom
-      return nil if type == :missing_atom
-      response['installed']
-    end
+    def sync
+      t = Time.new
 
-    def get_candidate_version(package_atom)
-      begin
-        result = @client.call(:package_releases, package_atom)
-      rescue SocketError
-        return nil
+      sync_file = File.join ns[:bits_dir], "#{provider_id}.sync"
+      last_sync = get_last_sync sync_file
+
+      if last_sync.nil?
+        content = read_full
+      else
+        content = read_partial last_sync
       end
 
-      raise MissingPackage.new package_atom if result.empty?
-      return result[0]
+      File.open(sync_file, 'w') do |f|
+        f.puts t.to_i.to_s
+      end
+
+      @cache.set content
+      @cache.save
     end
 
     def query(package_atom)
       candidate = get_candidate_version package_atom
+      raise MissingPackage.new package_atom if candidate.nil?
       current = get_installed_version package_atom
-      return Bits::Package.new(package_atom, current, candidate)
+      Bits::Package.new package_atom, current, candidate
     end
 
     def install(package)
@@ -82,5 +88,73 @@ module Bits
         end
       end
     end
+
+    private
+
+    def get_installed_version(package_atom)
+      type, response = @python.request :python_info, :atom => package_atom
+      return nil if type == :missing_atom
+      response['installed']
+    end
+
+    def get_candidate_version(package_atom)
+      begin
+        result = @client.call(:package_releases, package_atom)
+      rescue SocketError
+        return nil
+      end
+
+      return nil if result.empty?
+      return result[0]
+    end
+
+    # get the number from the specified file when we where last synced to
+    # upstream repository.
+    def get_last_sync(sync_file)
+      if File.file? sync_file
+        File.new(sync_file).read.to_i
+      else
+        nil
+      end
+    end
+
+    def read_partial(last_sync)
+      result = @client.call :changelog, last_sync
+
+      releases = Hash.new
+
+      result.each do |name, version, timestamp, purpose|
+        next if purpose != 'new release'
+
+        releases[name] = {
+          :atom => name,
+          :candidate => version,
+        }
+      end
+
+      releases
+    end
+
+    # TODO: works really slowly right now, fix it
+    def read_full
+      remote_packages = @client.call :list_packages
+
+      puts remote_packages.size
+
+      packages = Hash.new
+
+      remote_packages.each do |name|
+        candidate = get_candidate_version name
+
+        next if candidate.nil?
+
+        packages[name] = {
+          :atom => name,
+          :candidate => candidate,
+        }
+      end
+
+      packages
+    end
   end
 end

data/lib/bits/provider/rubygems.rb

@@ -0,0 +1,88 @@
+require 'bits/logging'
+require 'bits/command_provider'
+require 'bits/external_interface'
+require 'bits/provider_reporting'
+require 'bits/cache'
+
+module Bits
+  define_provider :rubygems, \
+    :desc => "Provides interface for Rubygems" \
+  do
+    include Bits::Logging
+    include Bits::CommandProvider
+    include Bits::ExternalInterface
+    include Bits::ProviderReporting
+    include Bits::Cache
+
+    GEM = 'gem'
+
+    def self.check
+      unless self.setup_interface :ruby, :capabilities => [:rubygems]
+        check_error "Could not setup required interface"
+        return false
+      end
+
+      log.debug "rubygems is available"
+      true
+    end
+
+    def setup
+      @client = interfaces[:ruby]
+      @cache = setup_cache ns[:bits_dir], provider_id
+    end
+
+    def sync
+      type, response = @client.request :rubygems_candidates
+
+      unless type == :candidates
+        raise "Expected rubygems_candidate response but got: #{type}"
+      end
+
+      candidates = response['candidates']
+
+      log.info "Synced #{candidates.size} gems"
+
+      cache = candidates.inject({}){|h, i| h[i['atom']] = i; h}
+
+      @cache.set cache
+      @cache.save
+    end
+
+    def query(atom)
+      candidate = @cache[atom]
+
+      type, info = @client.request :rubygems_info, \
+        :package => atom, \
+        :remote => candidate.nil?
+
+      raise MissingPackage.new atom if type == :missing_package
+      raise "Expected info response but got: #{type}" unless type == :info
+
+      installed = info['installed']
+
+      candidate = if candidate.nil?
+        info['candidate']
+      else
+        candidate['version']
+      end
+
+      Bits::Package.new(atom, installed, candidate)
+    end
+
+    def install(package)
+      execute do
+        unless run [GEM, 'install', package.atom]
+          raise "Could not install package '#{package.atom}'"
+        end
+      end
+    end
+
+    def remove(package)
+      execute do
+        unless run [GEM, 'uninstall', package.atom]
+          raise "Could not remove package '#{package.atom}'"
+        end
+      end
+    end
+  end
+end

data/lib/bits/repository.rb

@@ -46,7 +46,7 @@ module Bits
         raise MissingProvidedPackage.new atom
       end
 
-      return PackageProxy.new ppps, criteria
+      return PackageProxy.new atom, ppps, criteria
     end
 
     private

data/lib/bits/version.rb

@@ -1,3 +1,3 @@
 module Bits
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/lib/libexec/bits-python

@@ -20,7 +20,7 @@ class RequestError(Exception):
     pass
 
 
-class MissingRequestKey(Exception):
+class MissingRequestKey(RequestError):
     def __init__(self, key):
         super(MissingRequestKey, self).__init__(
             "Missing key '{0}' in request".format(key))
@@ -137,18 +137,18 @@ def guarded_handle_request(line):
 
 
 def main(args):
-    while True:
-        try:
+    try:
+        while True:
             line = sys.stdin.readline()
-        except KeyboardInterrupt:
-            break
 
-        if not line:
-            break
+            if not line:
+                break
 
-        response = guarded_handle_request(line)
-        print >>sys.stdout, json.dumps(response)
-        sys.stdout.flush()
+            response = guarded_handle_request(line)
+            print >>sys.stdout, json.dumps(response)
+            sys.stdout.flush()
+    except KeyboardInterrupt:
+        pass
 
     return 0
 

data/lib/libexec/bits-ruby

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+
+HAS_RUBYGEMS = true
+
+$load_path = Array.new $:
+
+HAS_HOMEBREW = begin
+  $: << '/usr/local/Library/Homebrew'
+
+  require 'global'
+  require 'formula'
+
+  true
+rescue LoadError
+  $:.replace $load_path
+  false
+end
+
+class RequestError < Exception; end
+
+class MissingRequestKey < RequestError
+    def initialize(key)
+        super "Missing key '#{key}' in request"
+    end
+end
+
+def ping_handler request
+    capabilities = []
+
+    capabilities << :homebrew if HAS_HOMEBREW
+    capabilities << :rubygems if HAS_RUBYGEMS
+
+    return {
+        :__type__ => "pong",
+        :capabilities => capabilities
+    }
+end
+
+def rubygems_info_handler request
+    remote = request['remote']
+    package = request['package']
+
+    if package.nil?
+        raise MissingRequestKey.new 'package'
+    end
+
+    candidate_version = if remote
+      rubygems_candidate_version package
+    else
+      nil
+    end
+
+    installed_version = rubygems_installed_version package
+
+    {
+        :__type__ => :info,
+        :installed => installed_version,
+        :candidate => candidate_version,
+    }
+end
+
+def rubygems_candidate_version package
+    dep = Gem::Dependency.new package
+    fetcher = Gem::SpecFetcher.fetcher
+    spec_tuples = fetcher.find_matching dep
+
+    if spec_tuples.empty?
+        return nil
+    end
+
+    spec, _ = spec_tuples[0]
+    _, version, _ = spec
+
+    version.version
+end
+
+def rubygems_installed_version package
+    result = Gem::Specification.find_all_by_name package
+    #result = Gem::Specification.source_index.find_name package
+    return nil if result.empty?
+    result.first.version.version
+end
+
+def iterate_candidates
+  fetcher = Gem::SpecFetcher.fetcher
+
+  fetcher.list.each do |source_uri, spec_tuples|
+    spec_tuples.each do |spec_tuple|
+      atom, version, _ = spec_tuple
+      yield atom, version.version
+    end
+  end
+end
+
+def rubygems_candidates_handler request
+  candidates = Array.new
+
+  iterate_candidates do |atom, version|
+    candidates << {
+      :atom => atom,
+      :version => version,
+    }
+  end
+
+  {
+    :__type__ => :candidates,
+    :candidates => candidates,
+  }
+end
+
+def homebrew_info_handler request
+    package = request['package']
+
+    if package.nil?
+        raise MissingRequestKey.new 'package'
+    end
+
+    installed, candidate = homebrew_get_version package
+
+    {
+        :__type__ => :info,
+        :installed => installed,
+        :candidate => candidate,
+    }
+end
+
+def homebrew_get_version(package)
+    begin
+        f = Formula.factory(package)
+    rescue FormulaUnavailableError
+        return [nil, nil]
+    end
+
+    [f.installed_version, f.version]
+end
+
+HANDLERS = {
+    :ping => :ping_handler,
+    :homebrew_info => :homebrew_info_handler,
+    :rubygems_info => :rubygems_info_handler,
+    :rubygems_candidates => :rubygems_candidates_handler,
+}
+
+def handle_request(line)
+    begin
+        request = JSON.load line
+    rescue
+        raise RequestError.new "Could not decode request, expected type: json"
+    end
+
+    request_type = request['__type__']
+
+    if request_type.nil?
+        raise RequestError.new "Missing 'type' in request"
+    end
+
+    request_type = request_type.to_sym
+
+    handler_name = HANDLERS[request_type]
+
+    if handler_name.nil?
+        raise RequestError.new "No handler for type '#{request_type}'"
+    end
+
+    begin
+        handler = method(handler_name)
+    rescue NameError
+        raise RequestError.new "No method for handler '#{request_type}'"
+    end
+
+    handler.call request
+end
+
+def guarded_handle_request(line)
+    handle_request line
+rescue RequestError => e
+    return {
+        :__type__ => "error",
+        :text => e.to_s,
+    }
+end
+
+def main
+    $stdin.each do |line|
+        response = guarded_handle_request line
+        $stdout.puts JSON.dump response
+        $stdout.flush
+    end
+
+    return 0
+rescue Interrupt
+    return 0
+end
+
+exit main