stickler 2.0.0a → 2.0.1

data/examples/config.ru

@@ -1,9 +1,12 @@
 #-----------------------------------------------------------------------
 # Example rackup file for an entire stickler stack
+#
+# -*- vim: set ft=ruby: -*-
 #-----------------------------------------------------------------------
 $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
 
-require 'stickler/web'
+require 'stickler'
 
-use Stickler::Web
-run Sinatra::Base
+tmp = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "tmp" ) )
+
+run Stickler::Server.new( tmp ).app

data/examples/gemcutter_repo.ru

@@ -1,4 +1,6 @@
 #-----------------------------------------------------------------------
+# -*- vim: set ft=ruby: -*-
+#
 # An Example remote repository that implements all the methods that are
 # required to satisfy being talked to by a Respository::Remote client.
 # This means it needs to speak:

data/examples/index_repo.ru

@@ -1,4 +1,6 @@
 #-----------------------------------------------------------------------
+#-*- vim: set ft=ruby: -*-
+#
 # Example rackup file for serving up a null repository.  This really 
 # would never be used in the wild, but it shows the basics of what 
 # is required to setup a stickler webstack

data/examples/local_repo.ru

@@ -1,14 +1,17 @@
 #-----------------------------------------------------------------------
+#-*- vim: set ft=ruby: -*-
+#
 # Example rackup file for serving up a single repository.  This repository
 # will respond to index and gem requests.
 #-----------------------------------------------------------------------
 $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
 
 require 'stickler/middleware/compression'
-require 'stickler/middleware/repo_local'
+require 'stickler/middleware/local'
 
-gem_dir = File.join( File.expand_path( File.dirname( __FILE__ ) ), "data" )
+gem_dir = File.expand_path( File.join( File.dirname( __FILE__ ), *%w[ .. spec data ]))
 
+puts gem_dir
 use ::Stickler::Middleware::Compression
-use ::Stickler::Middleware::RepoLocal, :repo_root => gem_dir
+use ::Stickler::Middleware::Local, :repo_root => gem_dir
 run ::Sinatra::Base

data/examples/mirror_repo.ru

@@ -1,4 +1,6 @@
 #-----------------------------------------------------------------------
+#-*- vim: set ft=ruby: -*-
+#
 # Example repository for serving up a Mirror repository.  This repo
 # will respond to mirroring requests and mirror gems from a remote
 # repository locally.

data/examples/not_found.ru

@@ -1,4 +1,6 @@
 #-----------------------------------------------------------------------
+#-*- vim: set ft=ruby: -*-
+#
 # Serve up the not found page for everything
 #-----------------------------------------------------------------------
 $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )

data/lib/stickler.rb

@@ -0,0 +1,12 @@
+module Stickler
+end
+
+require 'stickler/error'
+require 'stickler/paths'
+require 'stickler/middleware'
+require 'stickler/repository'
+require 'stickler/spec_lite'
+require 'stickler/version'
+require 'stickler/server'
+
+

data/lib/stickler/client.rb

@@ -0,0 +1,47 @@
+require 'trollop'
+require 'rubygems'
+require 'stickler/client/config_file'
+
+module Stickler
+  class Client
+
+    attr_reader :argv
+    attr_reader :sources
+
+    def self.config
+      ::Stickler::Client::ConfigFile.new
+    end
+
+    def initialize( argv = ARGV )
+      @argv          = argv
+    end
+
+    def parser
+      me = self # scoping forces this
+      @parser ||= Trollop::Parser.new do
+        banner me.class.banner
+        opt :server, "The gem or stickler server URL", :type => :string, :default => Client.config.server
+        opt :debug, "Output debug information for the server interaction", :default => false
+      end
+    end
+
+    def parse( argv )
+      opts = Trollop::with_standard_exception_handling( parser ) do
+        raise Trollop::HelpNeeded if argv.empty? # show help screen
+        o = parser.parse( argv )
+        yield parser if block_given?
+        return o
+      end
+      return opts
+    end
+
+    def remote_repo_for( opts )
+      Stickler::Repository::Remote.new( opts[:server], :debug => opts[:debug] ) 
+    end
+  end
+end
+
+require 'stickler/client/push'
+require 'stickler/client/yank'
+require 'stickler/client/mirror'
+require 'stickler/client/config'

data/lib/stickler/client/config.rb

@@ -0,0 +1,35 @@
+module Stickler
+  class Client
+    class Config < Stickler::Client
+      def self.banner
+<<-_
+Access or update the Stickler client configuration.  
+
+Usage: stickler config [options] 
+
+  Options:
+_
+      end
+
+      def parser
+        unless @parser then
+          @parser = super
+          @parser.opt( :upstream, "The upstream gem server from which to pull", :type => :string, :default => Client.config.upstream )
+          @parser.opt( :add, "Add upstream and/or server to the configuration", :type => :boolean )
+          @parser.opt( :list, "display the current configuration", :type => :boolean )
+        end
+        return @parser
+      end
+
+      def dump_config( opts )
+        puts "  server : #{Client.config.server}"
+        puts "upstream : #{Client.config.upstream}"
+      end
+
+      def run
+        opts = parse( self.argv )
+        dump_config( opts ) if Client.config.update( opts ) || opts[:list]
+      end
+   end
+  end
+end

data/lib/stickler/client/config_file.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'stickler/repository/rubygems_authenticator'
+
+module Stickler
+  class Client
+    class ConfigFile
+      def initalize
+        @updated = false
+      end
+
+      def config_path
+        File.join(Gem.user_home, '.gem', 'stickler')
+      end
+
+      def configuration
+        Gem.configuration.load_file(config_path)
+      end
+
+      def update( opts )
+        self.server   = opts[:server]   if opts[:server]
+        self.upstream = opts[:upstream] if opts[:upstream]
+        return updated?
+      end
+
+      def updated?
+        return @updated
+      end
+
+      def server
+        configuration[:server]
+      end
+
+      def server=( server )
+        config = configuration.merge( :server => server )
+        save_config( config )
+      end
+
+      def upstream
+        configuration[:upstream] || ::Stickler::Repository::RubygemsAuthenticator.rubygems_uri.to_s
+      end
+
+      def upstream=( upstream )
+        config = configuration.merge( :upstream => upstream )
+        save_config( config )
+      end
+
+      def save_config( config )
+        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
+        @updated = true
+      end
+    end
+  end
+end

data/lib/stickler/client/mirror.rb

@@ -0,0 +1,61 @@
+module Stickler
+  class Client
+    class Mirror < Stickler::Client
+      def self.banner
+<<-_
+Pull a specific version of a gem from an upstream gem server
+and store it in a stickler server.
+
+Usage: stickler mirror [options] --gem-version x.y.z gem
+
+  Options:
+_
+      end
+
+      def parser
+        unless @parser then
+          @parser = super
+          @parser.opt( :upstream, "The upstream gem server from which to pull", :type => :string, :default => Client.config.upstream )
+          @parser.opt( :gem_version,  "The version of the gem to yank (required)",  :type => :string, :required => true )
+          @parser.opt( :platform, "The platform of the gem to yank", :type => :string, :default => ::Gem::Platform::RUBY )
+        end
+        return @parser
+      end
+
+      def parse( argv )
+        gem_name = nil
+        opts = super( argv ) do |p|
+          raise Trollop::CommandlineError, "At least one gem is required to mirror" if p.leftovers.empty?
+          gem_name = p.leftovers.shift
+        end
+        opts[:gem_name] = gem_name
+        return opts
+      end
+
+      def resource_uri( opts )
+        opts[:server] || Client.config.server
+      end
+
+      def run
+        opts = parse( self.argv )
+        repo = remote_repo_for( opts )
+        spec = Stickler::SpecLite.new( opts[:gem_name], opts[:gem_version], opts[:platform] )
+        upstream_host = Addressable::URI.parse( opts[:upstream] ).host
+
+        $stdout.write "Asking #{repo.uri} to mirror #{spec.full_name} from #{upstream_host} : "
+        $stdout.flush
+
+        uri = [ repo.uri.join( upstream_host ), opts[:gem_name], opts[:gem_version], opts[:platform] ].join("/")
+        resource = repo.http.resource( uri )
+
+        resp = resource.post
+        $stdout.puts "OK -> #{repo.uri.join(resp.headers['Location'])}"
+      rescue Resourceful::UnsuccessfulHttpRequestError => he
+        resp = he.http_response
+        $stdout.puts "ERROR -> #{resp.body}"
+      rescue StandardError => e
+        $stdout.puts "ERROR -> #{e.message}"
+     end
+    end
+  end
+end

data/lib/stickler/client/push.rb

@@ -0,0 +1,50 @@
+require 'trollop'
+module Stickler
+  class Client
+    class Push < Stickler::Client
+      def self.banner
+<<-_
+Push one or more gems to a gemserver.
+
+Usage: stickler push [options] gemfile(s)
+
+  Options:
+_
+      end
+
+      def parse( argv )
+        gemfiles = []
+        opts = super do |p|
+          raise Trollop::CommandlineError, "At least one file is required to push" if p.leftovers.empty?
+          p.leftovers.each do |gemfile|
+            raise Trollop::CommandlineError, "#{gemfile} must be readable" unless File.readable?( gemfile )
+            gemfiles << File.expand_path( gemfile )
+          end
+        end
+        opts[:gemfiles] = gemfiles
+        return opts
+      end
+
+      def run
+        opts = parse( self.argv )
+        repo = remote_repo_for( opts )
+
+        width = opts[:gemfiles].collect { |g| g.length }.sort.last
+
+        puts "Pushing gem(s) to #{repo.uri} ..."
+        opts[:gemfiles].each do |gemfile|
+          begin
+            $stdout.write "  #{gemfile.ljust( width )} -> "
+            $stdout.flush
+            spec = repo.push( gemfile )
+            ok_msg = "OK"
+            ok_msg += " #{repo.uri_for_gem( spec )}"
+            $stdout.puts ok_msg
+          rescue Stickler::Repository::Error => e
+            $stdout.puts "ERROR: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stickler/client/yank.rb

@@ -0,0 +1,51 @@
+module Stickler
+  class Client
+    class Yank < Stickler::Client
+      def self.banner
+<<-_
+Remove a gem from the gemserver's index.  
+It will still be available for direct download.
+
+Usage: stickler yank [options] --gem-version x.y.z gem
+
+  Options:
+_
+      end
+
+      def parser
+        unless @parser then
+          @parser = super
+          @parser.opt( :gem_version,  "The version of the gem to yank (required)",  :type => :string, :required => true )
+          @parser.opt( :platform, "The platform of the gem to yank", :type => :string, :default => ::Gem::Platform::RUBY )
+        end
+        return @parser
+      end
+
+      def parse( argv )
+        gem_name = nil
+        opts = super( argv ) do |p|
+          raise Trollop::CommandlineError, "At least one gem is required to yank" if p.leftovers.empty?
+          gem_name = p.leftovers.shift
+        end
+        opts[:gem_name] = gem_name
+        return opts
+      end
+
+      def run
+        opts = parse( self.argv )
+        repo = remote_repo_for( opts )
+        spec = Stickler::SpecLite.new( opts[:gem_name], opts[:gem_version], opts[:platform] )
+
+        $stdout.write "Yanking gem #{spec.full_name} from #{repo.uri} : "
+        $stdout.flush
+        if spec = repo.yank( spec ) then
+          $stdout.puts "OK"
+        else
+          $stdout.puts "FAILURE"
+        end
+     rescue Stickler::Repository::Error => e
+        $stdout.puts "ERROR: #{e.message}"
+     end
+    end
+  end
+end

data/lib/stickler/logable.rb

@@ -0,0 +1,35 @@
+require 'logging'
+module Stickler
+
+  def self.app_name
+    @app_name || "stickler"
+  end
+
+  def self.app_name=( name )
+    @app_name = name
+  end
+
+  class Logging
+    def self.init
+      unless @initialized then
+        layout   = ::Logging::Layouts::Pattern.new( :pattern => "%5l %c : %m" )
+        appender = ::Logging::Appenders::Syslog.new( Stickler.app_name,
+                                                    :logopt => ::Syslog::Constants::LOG_CONS | ::Syslog::Constants::LOG_PID,
+                                                    :facility => ::Syslog::Constants::LOG_LOCAL0,
+                                                    :layout => layout)
+        ::Logging::Appenders['syslog'] = appender
+        logger = ::Logging::Logger[Stickler]
+        logger.add_appenders( appender )
+        @initialized = true
+      end
+      return @initialized
+    end
+  end
+
+  module Logable
+    def logger
+      Stickler::Logging.init
+      ::Logging::Logger[self]
+    end
+  end
+end

data/lib/stickler/middleware/gemcutter.rb

@@ -33,8 +33,10 @@ module Stickler::Middleware
     post '/api/v1/gems' do
       begin
         spec = @repo.add( request.body )
+        logger.info( "Pushed #{spec.full_name}" )
         return spec.to_s
       rescue Stickler::Repository::Error => e
+        logger.error( "Error adding #{spec.full_name} to repo : #{e}" )
         error( 500, "Error adding gem to repo: #{e}" )
       end
     end
@@ -43,8 +45,10 @@ module Stickler::Middleware
     delete '/api/v1/gems/yank' do
       spec = Stickler::SpecLite.new( params[:gem_name], params[:version] )
       if s = @repo.yank( spec ) then
+        logger.info( "Yanked #{spec.full_name}" )
         return "Yanked #{s.to_s}"
       else
+        logger.warn( "Did not Yank #{spec.full_name}" )
         error( 503, "Did not Yank #{spec.to_s}" )
       end
     end
@@ -54,6 +58,7 @@ module Stickler::Middleware
       full_name, name, version, platform = *params[:captures]
       spec = Stickler::SpecLite.new( name, version, platform )
       @repo.delete( spec )
+      logger.info( "Deleted #{spec.full_name}" )
       return "deleted gem #{spec.full_name}"
     end
   end