lib/git/webby.rb
# Standard requirements
require 'json'
require 'yaml'
# 3rd part requirements
require 'sinatra/base'
# Internal requirements
require 'git/webby/extensions'
# See <b>Git::Webby</b> for documentation.
module Git
# 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.
#
# This class configure the needed variables used by application. See
# Config::DEFAULTS for the values will be initialized by default.
#
# Basically, the +default+ attribute set the values that will be necessary
# by all applications.
#
# The HTTP-Backend application is configured by +http_backend+ attribute
# to set the Git RCP CLI. More details about this feature, see the
# {git-http-backend official
# page}[http://www.kernel.org/pub/software/scm/git/docs/git-http-backend.html]
#
# [*default*]
# Default configuration. All attributes will be used by all modular
# applications.
#
# *project_root* ::
# Sets the root directory where repositories have been
# placed.
# *git_path* ::
# Path to the git command line.
#
# [*http_backend*]
# HTTP-Backend configuration.
#
# *authenticate* ::
# Sets if authentication is required.
#
# *get_any_file* ::
# Like +http.getanyfile+.
#
# *upload_pack* ::
# Like +http.uploadpack+.
#
# *receive_pack* ::
# Like +http.receivepack+.
module Webby
class ProjectHandler #:nodoc:
# Path to git command
attr_reader :path
attr_reader :project_root
attr_reader :repository
def initialize(project_root, path = "/usr/bin/git")
@repository = nil
@path = check_path(File.expand_path(path))
@project_root = check_path(File.expand_path(project_root))
end
def path_to(*args)
File.join(@repository || @project_root, *(args.compact.map(&:to_s)))
end
def repository=(name)
@repository = check_path(path_to(name))
end
def cli(command, *args)
%Q[#{@path} #{args.unshift(command.to_s.gsub("_","-")).compact.join(" ")}]
end
def run(command, *args)
chdir{ %x[#{cli command, *args}] }
end
def read_file(*file)
File.read(path_to(*file))
end
def loose_object_path(*hash)
path_to(:objects, *hash)
end
def pack_idx_path(pack)
path_to(:objects, :pack, pack)
end
def info_packs_path
path_to(:objects, :info, :packs)
end
private
def repository_path(name)
bare = name =~ /\w\.git/ ? name : %W[#{name} .git]
check_path(path_to(*bare))
end
def check_path(path)
path && !path.empty? && File.ftype(path) && path
end
def chdir(&block)
Dir.chdir(@repository || @project_root, &block)
end
def ftype
{ "120" => "l", "100" => "-", "040" => "d" }
end
end
class Htpasswd #:nodoc:
def initialize(file)
require 'webrick/httpauth/htpasswd'
@handler = WEBrick::HTTPAuth::Htpasswd.new(file)
yield self if block_given?
end
def find(username) #:yield: password, salt
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
module GitHelpers #:nodoc:
def git
@git ||= ProjectHandler.new(settings.project_root, settings.git_path)
end
def repository
git.repository ||= (params[:repository] || params[:captures].first)
git
end
def content_type_for_git(name, *suffixes)
content_type("application/x-git-#{name}-#{suffixes.compact.join("-")}")
end
end
module AuthenticationHelpers #:nodoc:
def htpasswd
@htpasswd ||= Htpasswd.new(git.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 # AuthenticationHelpers
# Servers
autoload :HttpBackend, "git/webby/http_backend"
class << self
def config
@config ||= {
:default => {
:project_root => "/home/git",
:git_path => "/usr/bin/git"
},
:http_backend => {
:authenticate => true,
:get_any_file => true,
:upload_pack => true,
:receive_pack => false
}
}.to_struct
end
# Configure Git::Webby modules using keys. See Config for options.
def configure(&block)
yield config
config
end
def load_config_file(file)
YAML.load_file(file).to_struct.each_pair do |app, options|
options.each_pair do |option, value|
config[app][option] = value
end
end
config
rescue IndexError
abort "configuration option not found"
end
end
class Application < Sinatra::Base #:nodoc:
set :project_root, lambda { Git::Webby.config.default.project_root }
set :git_path, lambda { Git::Webby.config.default.git_path }
mime_type :json, "application/json"
end
end
end