geminabox-jgraichen 0.12.2.1

data/lib/geminabox/proxy/splicer.rb

@@ -0,0 +1,67 @@
+
+module Geminabox
+  module Proxy
+    class Splicer < FileHandler
+      
+      def self.make(file_name)
+        splicer = new(file_name)
+        splicer.create
+        splicer
+      end
+
+      def create
+        File.open(splice_path, 'w'){|f| f.write(new_content)}
+      end
+
+      def new_content
+        if local_file_exists?
+          merge_content
+        else
+          remote_content
+        end
+      end
+
+      def splice_path
+        proxy_path
+      end
+
+      def splice_folder_path
+        proxy_folder_path
+      end
+
+      def splice_file_exists?
+        file_exists? splice_path
+      end
+
+      def merge_content
+        if gzip?
+          merge_gziped_content
+        else
+          merge_text_content
+        end
+      end
+
+      def gzip?
+        /\.gz$/ =~ file_name
+      end
+
+      private
+      def merge_gziped_content
+        package(unpackage(local_content) | unpackage(remote_content))
+      end
+
+      def unpackage(content)
+        Marshal.load(Gem.gunzip(content))
+      end
+
+      def package(content)
+        Gem.gzip(Marshal.dump(content))
+      end
+
+      def merge_text_content
+        local_content.to_s + remote_content.to_s
+      end
+
+    end
+  end
+end

data/lib/geminabox/rubygems_dependency.rb

@@ -0,0 +1,27 @@
+require 'httpclient'
+require 'json'
+
+module Geminabox
+  module RubygemsDependency
+
+    class << self
+
+      def for(*gems)
+
+        url = [
+          rubygems_uri,
+          '?gems=',
+          gems.map(&:to_s).join(',')
+        ].join
+        body = HTTPClient.get_content(url)
+        JSON.parse(body)
+      end
+
+      def rubygems_uri
+        "https://bundler.rubygems.org/api/v1/dependencies.json"
+      end
+
+    end
+  end
+end
+

data/lib/geminabox/server.rb

@@ -0,0 +1,285 @@
+module Geminabox
+
+  class Server < Sinatra::Base
+    enable :static, :methodoverride
+
+    def self.delegate_to_geminabox(*delegate_methods)
+      delegate_methods.each{|m| set m, Geminabox.send(m)}
+    end
+
+    delegate_to_geminabox(
+      :public_folder,
+      :data,
+      :build_legacy,
+      :incremental_updates,
+      :views,
+      :allow_replace,
+      :gem_permissions,
+      :allow_delete,
+      :rubygems_proxy
+    )
+
+    if Server.rubygems_proxy
+      use Proxy::Hostess
+    else
+      use Hostess
+    end
+
+    class << self
+      def disallow_replace?
+        ! allow_replace
+      end
+
+      def allow_delete?
+        allow_delete
+      end
+
+      def fixup_bundler_rubygems!
+        return if @post_reset_hook_applied
+        Gem.post_reset{ Gem::Specification.all = nil } if defined? Bundler and Gem.respond_to? :post_reset
+        @post_reset_hook_applied = true
+      end
+
+      def reindex(force_rebuild = false)
+        fixup_bundler_rubygems!
+        force_rebuild = true unless incremental_updates
+        if force_rebuild
+          indexer.generate_index
+          dependency_cache.flush
+        else
+          begin
+            require 'geminabox/indexer'
+            updated_gemspecs = Geminabox::Indexer.updated_gemspecs(indexer)
+            Geminabox::Indexer.patch_rubygems_update_index_pre_1_8_25(indexer)
+            indexer.update_index
+            updated_gemspecs.each { |gem| dependency_cache.flush_key(gem.name) }
+          rescue => e
+            puts "#{e.class}:#{e.message}"
+            puts e.backtrace.join("\n")
+            reindex(:force_rebuild)
+          end
+        end
+      end
+
+      def indexer
+        Gem::Indexer.new(data, :build_legacy => build_legacy)
+      end
+
+      def dependency_cache
+        @dependency_cache ||= Geminabox::DiskCache.new(File.join(data, "_cache"))
+      end
+    end
+
+
+
+    before do
+      headers 'X-Powered-By' => "geminabox #{Geminabox::VERSION}"
+    end
+
+    get '/' do
+      @gems = load_gems
+      @index_gems = index_gems(@gems)
+      erb :index
+    end
+
+    get '/atom.xml' do
+      @gems = load_gems
+      erb :atom, :layout => false
+    end
+
+    get '/api/v1/dependencies' do
+      query_gems.any? ? Marshal.dump(gem_list) : 200
+    end
+
+    get '/api/v1/dependencies.json' do
+      query_gems.any? ? gem_list.to_json : {}
+    end
+
+    get '/upload' do
+      erb :upload
+    end
+
+    get '/reindex' do
+      self.class.reindex(:force_rebuild)
+      redirect url("/")
+    end
+
+    get '/gems/:gemname' do
+      gems = Hash[load_gems.by_name]
+      @gem = gems[params[:gemname]]
+      halt 404 unless @gem
+      erb :gem
+    end
+
+    delete '/gems/*.gem' do
+      unless self.class.allow_delete?
+        error_response(403, 'Gem deletion is disabled - see https://github.com/cwninja/geminabox/issues/115')
+      end
+      File.delete file_path if File.exists? file_path
+      self.class.reindex(:force_rebuild)
+      redirect url("/")
+    end
+
+    post '/upload' do
+      unless params[:file] && params[:file][:filename] && (tmpfile = params[:file][:tempfile])
+        @error = "No file selected"
+        halt [400, erb(:upload)]
+      end
+      handle_incoming_gem(Geminabox::IncomingGem.new(tmpfile))
+    end
+
+    post '/api/v1/gems' do
+      begin
+        handle_incoming_gem(Geminabox::IncomingGem.new(request.body))
+      rescue Object => o
+        File.open "/tmp/debug.txt", "a" do |io|
+          io.puts o, o.backtrace
+        end
+      end
+    end
+
+  private
+
+    def handle_incoming_gem(gem)
+      begin
+        GemStore.create(gem, params[:overwrite])
+      rescue GemStoreError => error
+        error_response error.code, error.reason
+      end
+
+      if api_request?
+        "Gem #{gem.name} received and indexed."
+      else
+        redirect url("/")
+      end
+    end
+
+    def api_request?
+      request.accept.first != "text/html"
+    end
+
+    def error_response(code, message)
+      halt [code, message] if api_request?
+      html = <<HTML
+<html>
+  <head><title>Error - #{code}</title></head>
+  <body>
+    <h1>Error - #{code}</h1>
+    <p>#{message}</p>
+  </body>
+</html>
+HTML
+      halt [code, html]
+    end
+
+    def file_path
+      File.expand_path(File.join(settings.data, *request.path_info))
+    end
+
+    def dependency_cache
+      self.class.dependency_cache
+    end
+
+    def all_gems
+      all_gems_with_duplicates.inject(:|)
+    end
+
+    def all_gems_with_duplicates
+      specs_files_paths.map do |specs_file_path|
+        if File.exists?(specs_file_path)
+          Marshal.load(Gem.gunzip(Gem.read_binary(specs_file_path)))
+        else
+          []
+        end
+      end
+    end
+
+    def specs_file_types
+      [:specs, :prerelease_specs]
+    end
+
+    def specs_files_paths
+      specs_file_types.map do |specs_file_type|
+        File.join(settings.data, spec_file_name(specs_file_type))
+      end
+    end
+
+    def spec_file_name(specs_file_type)
+      [specs_file_type, Gem.marshal_version, 'gz'].join('.')
+    end
+
+    def load_gems
+      @loaded_gems ||= Geminabox::GemVersionCollection.new(all_gems)
+    end
+
+    def index_gems(gems)
+      Set.new(gems.map{|gem| gem.name[0..0].downcase})
+    end
+
+    def gem_list
+      settings.rubygems_proxy ? combined_gem_list : local_gem_list
+    end
+
+    def query_gems
+      params[:gems].to_s.split(',')
+    end
+
+    def local_gem_list
+      query_gems.map{|query_gem| gem_dependencies(query_gem) }.flatten(1)
+    end
+
+    def remote_gem_list
+      RubygemsDependency.for(*query_gems)
+    end
+
+    def combined_gem_list
+      GemListMerge.from(local_gem_list, remote_gem_list)
+    end
+
+    helpers do
+      def spec_for(gem_name, version, platform = default_platform)
+        filename = [gem_name, version]
+        filename.push(platform) if platform != default_platform
+        spec_file = File.join(settings.data, "quick", "Marshal.#{Gem.marshal_version}", "#{filename.join("-")}.gemspec.rz")
+        Marshal.load(Gem.inflate(File.read(spec_file))) if File.exists? spec_file
+      end
+
+      def default_platform
+        'ruby'
+      end
+
+      # Return a list of versions of gem 'gem_name' with the dependencies of each version.
+      def gem_dependencies(gem_name)
+        dependency_cache.marshal_cache(gem_name) do
+          load_gems.
+            select { |gem| gem_name == gem.name }.
+            map    { |gem| [gem, spec_for(gem.name, gem.number, gem.platform)] }.
+            reject { |(_, spec)| spec.nil? }.
+            map do |(gem, spec)|
+              {
+                :name => gem.name,
+                :number => gem.number.version,
+                :platform => gem.platform,
+                :dependencies => runtime_dependencies(spec)
+              }
+            end
+        end
+      end
+
+
+
+      def runtime_dependencies(spec)
+        spec.
+          dependencies.
+          select { |dep| dep.type == :runtime }.
+          map    { |dep| name_and_requirements_for(dep) }
+      end
+
+      def name_and_requirements_for(dep)
+        name = dep.name.kind_of?(Array) ? dep.name.first : dep.name
+        [name, dep.requirement.to_s]
+      end
+    end
+  end
+
+end

data/lib/geminabox/version.rb

@@ -0,0 +1,3 @@
+module Geminabox
+  VERSION = '0.12.2.1' unless defined? VERSION
+end

data/lib/geminabox_client.rb

@@ -0,0 +1,60 @@
+require 'uri'
+require 'httpclient'
+
+class GeminaboxClient
+  attr_reader :url, :http_client
+
+  def initialize(url)
+    extract_username_and_password_from_url!(url)
+    @http_client = HTTPClient.new
+    @http_client.set_auth(url_for(:upload), @username, @password) if @username or @password
+    @http_client.www_auth.basic_auth.challenge(url_for(:upload)) # Workaround: https://github.com/nahi/httpclient/issues/63
+    @http_client.ssl_config.ssl_version = nil # https://github.com/nahi/httpclient/pull/186
+    @http_client.send_timeout = 0
+    @http_client.receive_timeout = 0
+  end
+
+  def extract_username_and_password_from_url!(url)
+    uri = URI.parse(url.to_s)
+    @username, @password = uri.user, uri.password
+    uri.user = uri.password = nil
+    uri.path = uri.path + "/" unless uri.path.end_with?("/")
+    @url = uri.to_s
+  end
+
+  def url_for(path)
+    url + path.to_s
+  end
+
+  def push(gemfile, options = {})
+    response = http_client.post(url_for(:upload), { 'file' => File.open(gemfile, "rb"), 'overwrite' => !!options[:overwrite] }, { 'Accept' => 'text/plain' })
+
+    if response.status < 300
+      response.body
+    else
+      raise GeminaboxClient::Error, "Error (#{response.code} received)\n\n#{response.body}"
+    end
+  end
+
+end
+
+class GeminaboxClient::Error < RuntimeError
+end
+
+module GeminaboxClient::GemLocator
+  def find_gem(dir)
+    gemname = File.split(dir).last
+    glob_matcher = "{pkg/,}#{gemname}-*.gem"
+    latest_gem_for(gemname, Dir.glob(glob_matcher)) or raise Gem::CommandLineError, NO_GEM_PROVIDED_ERROR_MESSAGE
+  end
+
+  def latest_gem_for(gemname, files)
+    regexp_matcher = %r{(?:pkg/)#{gemname}-(#{Gem::Version::VERSION_PATTERN})\.gem}
+    sorter = lambda{|v| Gem::Version.new(regexp_matcher.match(v)[1]) }
+    files.grep(regexp_matcher).max_by(&sorter)
+  end
+
+  extend self
+
+  NO_GEM_PROVIDED_ERROR_MESSAGE = "Couldn't find a gem in pkg, please specify a gem name on the command line (e.g. gem inabox GEMNAME)"
+end

data/lib/rubygems/commands/inabox_command.rb

@@ -0,0 +1,91 @@
+require 'rubygems/command'
+
+class Gem::Commands::InaboxCommand < Gem::Command
+  def description
+    'Push a gem up to your GemInABox'
+  end
+
+  def arguments
+    "GEM       built gem to push up"
+  end
+
+  def usage
+    "#{program_name} GEM"
+  end
+
+  def initialize
+    super 'inabox', description
+
+    add_option('-c', '--configure', "Configure GemInABox") do |value, options|
+      options[:configure] = true
+    end
+
+    add_option('-g', '--host HOST', "Host to upload to.") do |value, options|
+      options[:host] = value
+    end
+
+    add_option('-o', '--overwrite', "Overwrite Gem.") do |value, options|
+      options[:overwrite] = true
+    end
+  end
+
+  def last_minute_requires!
+    require 'yaml'
+    require File.expand_path("../../../geminabox_client.rb", __FILE__)
+  end
+
+  def execute
+    last_minute_requires!
+    return configure if options[:configure]
+    configure unless geminabox_host
+
+    if options[:args].size == 0
+      say "You didn't specify a gem, looking for one in . and in ./pkg/..."
+      gemfiles = [GeminaboxClient::GemLocator.find_gem(Dir.pwd)]
+    else
+      gemfiles = get_all_gem_names
+    end
+
+    send_gems(gemfiles)
+  end
+
+  def send_gems(gemfiles)
+    client = GeminaboxClient.new(geminabox_host)
+
+    gemfiles.each do |gemfile|
+      say "Pushing #{File.basename(gemfile)} to #{client.url}..."
+      begin
+        say client.push(gemfile, options)
+      rescue GeminaboxClient::Error => e
+        alert_error e.message
+        terminate_interaction(1)
+      end
+    end
+  end
+
+  def config_path
+    File.join(Gem.user_home, '.gem', 'geminabox')
+  end
+
+  def configure
+    say "Enter the root url for your personal geminabox instance (e.g. http://gems/)."
+    host = ask("Host:")
+    self.geminabox_host = host
+  end
+
+  def geminabox_host
+    @geminabox_host ||= options[:host] || Gem.configuration.load_file(config_path)[:host]
+  end
+
+  def geminabox_host=(host)
+    config = Gem.configuration.load_file(config_path).merge(:host => host)
+
+    dirname = File.dirname(config_path)
+    Dir.mkdir(dirname) unless File.exists?(dirname)
+
+    File.open(config_path, 'w') do |f|
+      f.write config.to_yaml
+    end
+  end
+
+end