git-webby 0.1.0

data/README.rdoc

@@ -0,0 +1,74 @@
+= Git-Webby - Web smarty for Git
+
+== DESCRIPTION
+
+This project was inspired in the {Grack}[http://github.com/schacon/grack]
+Smart-HTTP server handler (written by
+{Scott Chacon}[http://github.com/schacon]) but developed using
+{Sinatra}[http://www.sinatrarb.com] and aims replace the original
+`git-http-backend` including new features.
+
+The main goal of the <b>Git-Webby</b> is implement the following useful features.
+
+- Smart-HTTP, based on _git-http-backend_.
+- Authentication flexible based on database or configuration file like .+htpasswd+.
+- API to get information about repository.
+
+== SINOPSIS
+
+Install the Git-Webby using {Rubygems}[http://rubygems.org/gems/git-webby].
+
+  gem install git-webby
+
+Or fork the project hosted on {Github}[http://github.com/codigorama/git-webby].
+
+  git clone https://github.com/codigorama/git-webby.git
+  ...
+  cd git-webby
+  rake install
+
+Configure your Rackup file (<tt>config.ru</tt>) using the following instructions:
+
+  # config.ru
+  require "git/webby"
+
+  Git::Webby::HttpBackend.configure do |server|
+    server.project_root = "/home/git/repositories"
+    server.git_path     = "/usr/bin/git"
+    server.get_any_file = true
+    server.upload_pack  = true
+    server.receive_pack = false
+    server.authenticate = true
+  end
+
+  $ rackup --port 2011 --daemonize
+  $ git clone http://localhost:2011/mycode.git
+
+You can use the <tt>.netrc</tt> for improve your connection. Put this:
+
+  machine <host> login <username> password <password>
+
+The Git-Webby is under development, so there are still many improvements to be
+made. Please, help us to improve the project with your feedback to
+{issues}[http://github.com/codigorama/git-webby] or sending email to
+{opensource@codigorama.com}[mailto:opensource@codigorama.com].
+
+Discuss in {Google Groups}[http://groups.google.com/group/git-webby].
+
+== AUTHORS
+
+Written by Hallison Batista <hallison@codigorama.com>.
+
+== BUGS
+
+If you find a bug, please report it at the Git-Webby project's
+{issues tracker}[http://github.com/codigorama/git-webby] on Github.
+
+== LICENSE
+
+Git-Webby is Copyright (c) 2011 Hallison Batista, Codigorama.
+
+It is free software, and may be redistributed under the terms specified in
+LICENSE.txt.
+
+

data/Rakefile

@@ -0,0 +1,44 @@
+#:nopkg:
+ENV["RUBYLIB"] = "#{File.dirname(__FILE__)}/lib"
+ENV["RUBYOPT"] = "-rubygems"
+#:
+
+require "git/webby"
+
+def spec
+  @spec ||= Gem::Specification.load("git-webby.gemspec")
+end
+
+desc "Run tests"
+task :test, [:file] do |spec, args|
+  Dir["test/#{args.file}*_test.rb"].each do |file|
+    sh "ruby #{file}"
+  end
+end
+
+desc "API Documentation (RDoc)"
+task :doc do
+  sh "rdoc -o doc/api -H -f hanna -m README.rdoc"
+end
+
+desc "Build #{spec.file_name}"
+task :build => "#{spec.name}.gemspec" do
+  sh "gem build #{spec.name}.gemspec"
+end
+
+desc "Release #{spec.file_name}"
+task :release do
+  sh "gem push #{spec.file_name}"
+end
+
+desc "Install gem file #{spec.file_name}"
+task :install => :build do
+  sh "gem install -l #{spec.file_name}"
+end
+
+desc "Uninstall gem #{spec.name} v#{spec.version}"
+task :uninstall do
+  sh "gem uninstall -l #{spec.name} -v #{spec.version}"
+end
+
+task :default => :test

data/doc/releases/v0.1.0.rdoc

@@ -0,0 +1,11 @@
+== Git-Webby v0.1.0
+
+Implementation of the basic features:
+
+- Smart-HTTP implementation.
+- Authentication using +htpasswd+ features (only crypt algorithm).
+- Basic configuration in Rackup file.
+
+This is a beta version. For more informations about this release,
+please visit <http://github.com/codigorama/git-webby>.
+

data/git-webby.gemspec

@@ -0,0 +1,32 @@
+require "git/webby"
+
+Gem::Specification.new do |spec|
+  spec.platform          = Gem::Platform::RUBY
+  spec.name              = "git-webby"
+  spec.summary           = "Git Web implementation of the Smart HTTP and other features"
+  spec.authors           = ["Hallison Batista"]
+  spec.email             = "hallison@codigorama.com"
+  spec.homepage          = "http://github.com/codigorama/git-webby"
+  spec.rubyforge_project = spec.name
+  spec.version           = Git::Webby::VERSION
+  spec.date              = Git::Webby::RELEASE
+  spec.test_files        = spec.files.select{ |path| path =~ /^test\/.*/ }
+  spec.require_paths     = ["lib"]
+  spec.files             = %x[git ls-files].split.reject do |out|
+    out =~ %r{^\.} || out =~ %r{/^doc/api/}
+  end
+  spec.description       = <<-end.gsub /^    /,''
+    Git::Webby is a implementation of the several features:
+    - Smart HTTP which works like as git-http-backend.
+    - Show info pages about the projects.
+  end
+  spec.post_install_message = <<-end.gsub(/^[ ]{4}/,'')
+    #{'-'*78}
+    Git::Webby v#{spec.version}
+
+    Thanks for use Git::Webby.
+    #{'-'*78}
+  end
+  spec.add_dependency "sinatra", ">= 1.0"
+end
+

data/lib/git/webby.rb

@@ -0,0 +1,145 @@
+# See <b>Git::Webby</b> for documentation.
+module Git
+
+  # Internal requirements
+  require "git/webby/version"
+
+  # The main goal of the <b>Git::Webby</b> is implement the following useful
+  # features.
+  #
+  # - Smart-HTTP, based on _git-http-backend_.
+  # - Authentication flexible based on database or configuration file like <tt>.htpasswd</tt>.
+  # - API to get information about repository.
+  module Webby
+
+    module RepositoryUtils # :nodoc:
+      def project_path_to(*args)
+        File.join(settings.project_root.to_s, *(args.map(&:to_s)))
+      end
+
+      def git_dir(name)
+        unless name =~ /\w\.git/ # not bare directory
+          File.join(name, ".git")
+        else
+          name
+        end
+      end
+
+      def path_to(name, *args)
+        project_path_to(git_dir(name), *args)
+      end
+
+      def read_file(dirname, *file)
+        File.read(path_to(dirname, *file))
+      end
+
+      def chdir(dirname, &block)
+        Dir.chdir(path_to(dirname), &block)
+      end
+
+      def git_cli(command, *args)
+        %Q[#{settings.git_path} #{args.unshift(command.to_s.gsub("_","-")).compact.join(" ")}]
+      end
+
+      def git_run(command, *args)
+        %x[#{git_cli command, *args}]
+      end
+
+    end
+
+    # This class configure the needed variables used by application.
+    # 
+    # For HTTP-Backend configuration
+    #
+    # The following attributes was necessary by +http_backend+:
+    #
+    # *project_root*  :: Directory that contains all git repositories.
+    # *git_path*      :: Path to git command line program.
+    # *get_any_file*  :: Like <tt>http.getanyfile</tt> configuration.
+    # *upload_pack*   :: Like <tt>http.uploadpack</tt> configuration.
+    # *receive_pack*  :: Like <tt>http.receivepack</tt> configuration.
+    class Config
+
+      # Configuration for HTTP Backend variables
+      attr_accessor :http_backend
+
+      def initialize(attributes = {}) # :yields: config
+        attributes.each do |key, value|
+          self.send("#{key}=", value) if self.respond_to? key
+        end
+        yield self if block_given?
+      end
+
+      def self.load_file(file)
+        require "yaml"
+        new(YAML.load_file(file))
+      end
+
+    end
+
+    class Htgroup #:nodoc:
+      require "webrick/httpauth/htgroup"
+
+      def initialize(file)
+        @handler = WEBrick::HTTPAuth::Htgroup.new(file)
+        yield self if block_given?
+      end
+    end
+
+    class Htpasswd #:nodoc:
+      require "webrick/httpauth/htpasswd"
+
+      def initialize(file)
+        @handler = WEBrick::HTTPAuth::Htpasswd.new(file)
+        yield self if block_given?
+      end
+
+      def find(username)
+        password = @handler.get_passwd(nil, username, false)
+        if block_given?
+          yield password ? [password, password[0,2]] : [nil, nil]
+        else
+          password
+        end
+      end
+
+      def authenticated?(username, password)
+        self.find username do |crypted, salt|
+          crypted && salt && crypted == password.crypt(salt)
+        end
+      end
+
+      def create(username, password)
+        @handler.set_passwd(nil, username, password)
+      end
+      alias update create
+
+      def destroy(username)
+        @handler.delete_passwd(nil, username)
+      end
+
+      def include?(username)
+        users.include? username
+      end
+
+      def size
+        users.size
+      end
+
+      def write!
+        @handler.flush
+      end
+
+      private
+
+      def users
+        @handler.each{|username, password| username }
+      end
+    end
+
+    # Applications
+    autoload :HttpBackend, "git/webby/http_backend"
+
+  end
+
+end

data/lib/git/webby/http_backend.rb

@@ -0,0 +1,248 @@
+module Git::Webby
+
+  module HttpBackendUtils #:nodoc:
+
+    include RepositoryUtils
+
+    def repository
+      params[:repository]
+    end
+
+    def content_type_for_git(name, *suffixes)
+      content_type("application/x-git-#{name}-#{suffixes.compact.join("-")}")
+    end
+
+    def service_request?
+      not params[:service].nil?
+    end
+
+    # select_service feature
+    def service
+      @service = params[:service]
+      return false if @service.nil?
+      return false if @service[0, 4] != "git-"
+      @service = @service.gsub("git-", "")
+    end
+
+    # pkt_write feature
+    def packet_write(line)
+      (line.size + 4).to_s(base=16).rjust(4, "0") + line
+    end
+
+    # pkt_flush feature
+    def packet_flush
+      "0000"
+    end
+
+    # hdr_nocache feature
+    def header_nocache
+      headers "Expires"       => "Fri, 01 Jan 1980 00:00:00 GMT",
+              "Pragma"        => "no-cache",
+              "Cache-Control" => "no-cache, max-age=0, must-revalidate"
+    end
+
+    # hdr_cache_forever feature
+    def header_cache_forever
+      now = Time.now
+      headers "Date"          => now.to_s,
+              "Expires"       => (now + 31536000).to_s,
+              "Cache-Control" => "public, max-age=31536000"
+    end
+
+    # select_getanyfile feature
+    def read_any_file
+      unless settings.get_any_file
+        halt 403, "Unsupported service: getanyfile"
+      end
+    end
+
+    # get_text_file feature
+    def read_text_file(repository, *file)
+      read_any_file
+      header_nocache
+      content_type "text/plain"
+      read_file(repository, *file)
+    end
+
+    # get_loose_object feature
+    def send_loose_object(repository, hash_prefix, hash_suffix)
+      read_any_file
+      header_cache_forever
+      content_type_for_git :loose, :object
+      send_file(path_to(repository, "objects", hash_prefix, hash_suffix))
+    end
+
+    # get_pack_file and get_idx_file
+    def send_pack_idx_file(repository, pack, idx = false)
+      read_any_file
+      header_cache_forever
+      content_type_for_git :packed, :objects, (idx ? :toc : nil)
+      send_file(path_to(repository, "objects", "pack", pack))
+    end
+
+    def send_info_packs(repository)
+      read_any_file
+      header_nocache
+      content_type "text/plain; charset=utf-8"
+      send_file(path_to(repository, "objects", "info", "packs"))
+    end
+
+    # run_service feature
+    def run_advertisement(repository, service)
+      header_nocache
+      content_type_for_git service, :advertisement
+      chdir repository do
+        response.body  = ""
+        response.body += packet_write("# service=git-#{service}\n")
+        response.body += packet_flush
+        response.body += git_run(service, "--stateless-rpc --advertise-refs .")
+        response.finish
+      end
+    end
+
+    def run_process(repository, service)
+      content_type_for_git service, :result
+      input   = request.body.read
+      command = git_cli(service, "--stateless-rpc .")
+      chdir repository do
+        # This source has extracted from Grack written by Scott Chacon.
+        IO.popen(command, File::RDWR) do |pipe|
+          pipe.write(input)
+          while !pipe.eof?
+            block = pipe.read(8192) # 8M at a time
+            response.write block    # steam it to the client
+          end
+        end # IO
+        response.finish
+      end
+    end
+
+  end # HttpBackendUtils
+
+  module HttpBackendAuthentication #:nodoc:
+
+    def htpasswd
+      @htpasswd ||= Htpasswd.new(project_path_to("htpasswd"))
+    end
+
+    def authentication
+      @authentication ||= Rack::Auth::Basic::Request.new request.env
+    end
+
+    def authenticated?
+      request.env["REMOTE_USER"] && request.env["git.webby.authenticated"]
+    end
+
+    def authenticate(username, password)
+      checked   = [ username, password ] == authentication.credentials
+      validated = authentication.provided? && authentication.basic?
+      granted   = htpasswd.authenticated? username, password
+      if checked and validated and granted
+        request.env["git.webby.authenticated"] = true
+        request.env["REMOTE_USER"] = authentication.username
+      else
+        nil
+      end
+    end
+
+    def unauthorized!(realm = Git::Webby::info)
+      headers "WWW-Authenticate" => %(Basic realm="#{realm}")
+      throw :halt, [ 401, "Authorization Required" ]
+    end
+
+    def bad_request!
+      throw :halt, [ 400, "Bad Request" ]
+    end
+
+    def authenticate!
+      return if authenticated?
+      unauthorized! unless authentication.provided?
+      bad_request!  unless authentication.basic?
+      unauthorized! unless authenticate(*authentication.credentials)
+      request.env["REMOTE_USER"] = authentication.username
+    end
+
+    def access_granted?(username, password)
+      authenticated? || authenticate(username, password)
+    end
+
+  end
+
+  require "sinatra/base"
+
+  # The Smart HTTP handler server. This is the main Web application which respond to following requests:
+  #
+  # <repo.git>/HEAD           :: HEAD contents
+  # <repo.git>/info/refs      :: Text file that contains references.
+  # <repo.git>/objects/info/* :: Text file that contains all list of packets, alternates or http-alternates.
+  # <repo.git>/objects/*/*    :: Git objects, packets or indexes.
+  # <repo.git>/upload-pack    :: Post an upload packets.
+  # <repo.git>/receive-pack   :: Post a receive packets.
+  #
+  # See ::configure for more details.
+  class HttpBackend < Sinatra::Base
+
+    helpers HttpBackendUtils
+
+    set :project_root, File.expand_path("#{File.dirname(__FILE__)}/git")
+    set :git_path,     "/usr/bin/git"
+    set :get_any_file, true
+    set :upload_pack,  true
+    set :receive_pack, false
+    set :authenticate, false
+
+    def self.configure(*envs, &block)
+      super(*envs, &block)
+      self
+    end
+
+    before do
+      authenticate! if settings.authenticate
+    end
+
+    # implements the get_text_file function
+    get "/:repository/HEAD" do |repository|
+      read_text_file(repository, "HEAD")
+    end
+
+    # implements the get_info_refs function
+    get "/:repository/info/refs" do |repository|
+      if service_request? # by URL query parameters
+        run_advertisement repository, service
+      else
+        read_text_file(repository, :info, :refs)
+      end
+    end
+
+    # implements the get_text_file and get_info_packs functions
+    get %r{/(.*?)/objects/info/(packs|alternates|http-alternates)$} do |repository, file|
+      if file == "packs"
+        send_info_packs(repository)
+      else
+        read_text_file(repository, :objects, :info, file)
+      end
+    end
+
+    # implements the get_loose_object function
+    get %r{/(.*?)/objects/([0-9a-f]{2})/([0-9a-f]{38})$} do |repository, prefix, suffix|
+      send_loose_object(repository, prefix, suffix)
+    end
+
+    # implements the get_pack_file and get_idx_file functions
+    get %r{/(.*?)/objects/pack/(pack-[0-9a-f]{40}.(pack|idx))$} do |repository, pack, ext|
+      send_pack_idx_file(repository, pack, ext == "idx")
+    end
+
+    # implements the service_rpc function
+    post "/:repository/:service" do |repository, rpc|
+      run_process repository, service
+    end
+
+  private
+
+    helpers HttpBackendAuthentication
+
+  end # HttpBackend
+
+end # Git::Webby
+