dtk-common 0.5.11

data/lib/git_repo/adapters/rugged/common.rb

@@ -0,0 +1,34 @@
+module DtkCommon
+  class GitRepo::Adapter::Rugged
+    class Branch
+      attr_reader :rugged_repo,:branch
+      def initialize(rugged_repo,branch)
+        @rugged_repo = rugged_repo
+        @branch = branch
+      end
+    end
+
+    module CommonMixin
+     private
+      def branch()
+        @repo_branch.branch()
+      end
+      def rugged_repo()
+        @repo_branch.rugged_repo()
+      end
+
+      def lookup(sha)
+        rugged_repo().lookup(sha)
+      end
+    end
+
+    class Obj
+      include CommonMixin
+
+      def initialize(repo_branch)
+        @repo_branch = repo_branch
+      end
+    end
+  end
+end
+

data/lib/git_repo/adapters/rugged/tree.rb

@@ -0,0 +1,40 @@
+module DtkCommon
+  class GitRepo::Adapter::Rugged
+    class Tree < Obj
+      def initialize(repo_branch,rugged_tree)
+        super(repo_branch)
+        @rugged_tree = rugged_tree
+      end
+
+      def get_file_content(path)
+        if blob = get_blob(path)
+          blob.content
+        end
+      end
+
+      def list_files()
+        ret = Array.new
+        @rugged_tree.walk_blobs do |root,entry|
+          ret << "#{root}#{entry[:name]}"
+        end
+        ret
+      end
+
+     private
+      def get_blob(path)
+        ret = nil
+        dir = ""; file_part = path
+        if path =~ /(.+\/)([^\/]+$)/
+          dir = $1; file_part = $2
+        end
+        @rugged_tree.walk_blobs do |root,entry|
+          if root == dir and entry[:name] == file_part
+            return Blob.new(@repo_branch,entry)
+          end
+        end
+        ret
+      end
+
+    end
+  end
+end

data/lib/git_repo/adapters/rugged.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../git_repo.rb',File.dirname(__FILE__))
+require 'rugged'
+module DtkCommon
+  class GitRepo; class Adapter
+    class Rugged
+      require File.expand_path('rugged/common',File.dirname(__FILE__))
+      require File.expand_path('rugged/commit',File.dirname(__FILE__))
+      require File.expand_path('rugged/tree',File.dirname(__FILE__))
+      require File.expand_path('rugged/blob',File.dirname(__FILE__))
+      include CommonMixin
+
+      def initialize(repo_path,branch=nil)
+        if branch.nil?
+          raise Error.new("Not implemented yet creating Rugged adapter w/o a branch")
+        end
+        @repo_branch = Branch.new(::Rugged::Repository.new(repo_path),branch)
+      end
+
+      def get_file_content(path)
+        get_tree().get_file_content(path)
+      end
+
+      def list_files()
+         get_tree().list_files()
+      end
+      
+     private
+      def get_tree()
+        get_commit().tree()
+      end
+
+      def get_commit()
+        if rugged_ref = rugged_repo().refs.find {|ref|ref.name == "refs/heads/#{branch}"}
+          Commit.new(@repo_branch,lookup(rugged_ref.target))
+        else
+          raise ErrorUsage.new("Branch (#{branch} not found in repo (#{pp_repo()})")
+        end
+      end 
+      
+      def pp_repo()
+        rugged_repo().path()
+      end
+    end
+  end; end
+end

data/lib/git_repo.rb

@@ -0,0 +1,93 @@
+require File.expand_path('common_patch',File.dirname(__FILE__))
+require File.expand_path('dynamic_loader',File.dirname(__FILE__))
+#TODO: this will eventually replace the grit_adapter classes
+module DtkCommon
+  class GitRepo
+    class Adapter 
+    end
+
+    def initialize(repo_path)
+      @repo_path = repo_path
+      @adapters = Hash.new
+    end
+
+    class Branch < self
+      def initialize(repo_path,branch='master')
+        super(repo_path)
+        @branch = branch
+      end
+      private
+       def adapter_initialize_args()
+         [@repo_path,@branch]
+       end
+    end
+
+    def method_missing(method_name,*args,&block)
+      if adapter_name = self.class.find_adapter_name(method_name)
+        
+        adapter = (@adapters[adapter_name] ||= Hash.new)[branch_index()] ||= self.class.load_and_return_adapter_class(adapter_name).new(*adapter_initialize_args())
+        execution_wrapper do
+          adapter.send(method_name,*args,&block)
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_name)
+      super(method_name) or self.class.find_adapter_name(method_name)
+    end
+
+    def self.implements_method?(method_name)
+      !!find_adapter_name(method_name)
+    end
+
+   private
+    def adapter_initialize_args()
+      [@repo_path]
+    end
+
+    def branch_index()
+      @branch||"---NONE"
+    end
+
+    def execution_wrapper(&block)
+      begin
+        yield
+       rescue => e 
+        Log.error(([e.to_s]+e.backtrace).join("\n"))
+        error = (e.kind_of?(::DtkCommon::Error) ? e : ::DtkCommon::Error.new(e.to_s))
+        raise error
+      end
+    end
+
+    def self.load_and_return_adapter_class(adapter_name)
+      (@adapter_classes ||= Hash.new)[adapter_name] ||= DynmamicLoader.load_and_return_adapter_class(:git_repo,adapter_name,:base_class => Adapter)
+    end
+
+    def self.find_adapter_name(method_name)
+      @adapter_names ||= Hash.new
+      return @adapter_names[method_name] if @adapter_names.has_key?(method_name)
+      ret = Array(AdaptersForMethods[method_name]||[]).find do |adapter_name|
+        condition = AdapterConditions[adapter_name]
+        condition.nil? or condition.call()
+      end
+      @adapter_names[method_name] = ret 
+    end
+
+    #for each hash value form is scalar or array of adapters to try in order
+    AdaptersForMethods = {
+      :get_file_content => :rugged,
+      :list_files => :rugged
+    }
+
+    AdapterConditions = {
+#      TODO: too restrictive; wil delete
+#      :rugged => proc{!::Gem::Specification::find_all_by_name('rugged',::Gem::Requirement.new(NailedRuggedVersion)).empty?}
+    }
+  end
+end
+
+
+
+

data/lib/gitolite/configuration.rb

@@ -0,0 +1,35 @@
+module Gitolite
+  class Configuration
+
+    attr_reader :repositories_path, :user_group_path, :keydir_path, :home_dir
+
+    def initialize(
+        repo_path_        = 'conf/repo-configs', 
+        user_group_path_  = 'conf/group-defs', 
+        keydir_path_      = 'keydir',
+        home_dir_         = nil
+      )
+    
+      @repositories_path = repo_path_
+      @user_group_path = user_group_path_
+      @keydir_path = keydir_path_
+      @home_dir = home_dir_
+    end
+
+    def user_key_path(username)
+      "#{@keydir_path}/#{username}.pub"
+    end
+
+    def user_group_path(group_name)
+      "#{@user_group_path}/#{group_name}.conf"
+    end
+
+    def repo_path(repo_name)
+      "#{@repositories_path}/#{repo_name}.conf"
+    end
+
+    def bare_repo_path(repo_name)
+      "#{@home_dir}/repositories/#{repo_name}.git"
+    end 
+  end
+end

data/lib/gitolite/errors.rb

@@ -0,0 +1,5 @@
+module Gitolite
+  class Duplicate   < StandardError; end
+  class NotFound    < StandardError; end
+  class ParseError  < StandardError; end
+end

data/lib/gitolite/grit/adapter.rb

@@ -0,0 +1,101 @@
+require 'grit'
+
+module Gitolite
+  module Git
+    class Adapter
+    
+      DEFAULT_BRANCH = 'master'
+    
+      def initialize(repo_dir,branch='master')
+        @repo_dir = repo_dir
+        @branch = branch
+        @grit_repo = nil
+        begin
+          @grit_repo = ::Grit::Repo.new(repo_dir)
+         rescue ::Grit::NoSuchPathError
+          repo_name = repo_dir.split("/").last.gsub("\.git","")
+          #TODO: change to usage error
+          raise Error::NotFound, "Repo (#{repo_name}) - path '#{repo_dir}' does not exist"
+         rescue => e
+          raise e
+        end
+      end
+    
+      def branches()
+        @grit_repo.branches.map{|h|h.name}
+      end
+    
+      def ls_r(depth=nil,opts={})
+        tree_contents = tree.contents
+        ls_r_aux(depth,tree_contents,opts)
+      end
+    
+      def path_exists?(path)
+        not (tree/path).nil?
+      end
+    
+      def file_content(path)
+        tree_or_blob = tree/path
+        tree_or_blob && tree_or_blob.kind_of?(::Grit::Blob) && tree_or_blob.data
+      end
+    
+      def push()
+        Git_command__push_mutex.synchronize do 
+          git_command(:push,"origin", "#{@branch}:refs/heads/#{@branch}")
+        end
+      end
+    
+      def push_to_mirror_repo(mirror_repo)
+        git_command(:push,"--mirror",mirror_repo)
+      end
+    
+      Git_command__push_mutex = Mutex.new
+    
+      def pull()
+        git_command(:pull,"origin",@branch)
+      end
+    
+     private
+      def tree()
+        @grit_repo.tree(@branch)
+      end
+    
+      def ls_r_aux(depth,tree_contents,opts={})
+        ret = Array.new
+        return ret if tree_contents.empty?
+        if depth == 1
+          ret = tree_contents.map do |tc|
+            if opts[:file_only]
+              tc.kind_of?(::Grit::Blob) && tc.name 
+            elsif opts[:directory_only]
+              tc.kind_of?(::Grit::Tree) && tc.name
+            else
+              tc.name
+            end
+          end.compact
+          return ret
+        end
+    
+        tree_contents.each do |tc|
+          if tc.kind_of?(::Grit::Blob)
+            unless opts[:directory_only]
+              ret << tc.name
+            end
+          else
+            dir_name = tc.name
+            ret += ls_r_aux(depth && depth-1,tc.contents).map{|r|"#{dir_name}/#{r}"}
+          end
+        end
+        ret
+      end
+    
+      def git_command(cmd,*args)
+        @grit_repo.git.send(cmd, cmd_opts(),*args)
+      end
+      def cmd_opts()
+        {:raise => true, :timeout => 60}
+      end
+    
+    end
+  end
+end

data/lib/gitolite/grit/file_access.rb

@@ -0,0 +1,51 @@
+module Gitolite
+  module Git
+    class FileAccess < Adapter
+
+      def add_file(file_rel_path,content)
+        content ||= String.new
+        file_path = qualified_path(file_rel_path)
+        chdir_and_checkout do
+          File.open(file_path,"w"){|f|f << content}
+          git_command(:add,file_path)
+        end
+      end
+
+      def remove_file(file_rel_path)
+        file_path = qualified_path(file_rel_path)
+        chdir_and_checkout do
+          if File.file?(file_path)
+            git_command(:rm,file_path)
+          end
+        end
+      end
+      
+      def commit(commit_msg)
+        #TODO is chdir_and_checkout needed
+        chdir_and_checkout do
+          @grit_repo.commit_index(commit_msg)
+        end
+      end
+
+    private
+
+      def qualified_path(file_rel_path)
+        "#{@repo_dir}/#{file_rel_path}"
+      end
+
+      def chdir_and_checkout(branch=nil,&block)
+        branch ||= @branch
+        Dir.chdir(@repo_dir) do 
+          current_head = @grit_repo.head.name
+          git_command(:checkout,branch) unless current_head == branch
+          return unless block
+          yield
+          unless current_head == branch
+            git_command(:checkout,current_head)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/gitolite/init.rb

@@ -0,0 +1,16 @@
+# use to require all needed files needed for running dtk-common gitolite lib
+require 'grit'; require 'erubis'
+
+Grit.debug = true
+
+
+require File.expand_path('manager.rb', File.dirname(__FILE__))
+require File.expand_path('configuration.rb', File.dirname(__FILE__))
+require File.expand_path('errors.rb', File.dirname(__FILE__))
+
+require File.expand_path('grit/adapter.rb', File.dirname(__FILE__))
+require File.expand_path('grit/file_access.rb', File.dirname(__FILE__))
+
+require File.expand_path('utils.rb', File.dirname(__FILE__))
+require File.expand_path('repo.rb', File.dirname(__FILE__))
+require File.expand_path('user_group.rb', File.dirname(__FILE__))

data/lib/gitolite/manager.rb

@@ -0,0 +1,158 @@
+
+require 'fileutils'
+
+module Gitolite
+  class Manager
+
+    attr_accessor :repos, :user_groups, :configuration, :logger, :commit_messages
+    attr_reader :gitolite_path
+
+    def initialize(gitolite_path, override_configuration = nil)
+      @repos, @user_groups, @commit_messages = [], [], []
+      @gitolite_path = gitolite_path
+      @configuration = override_configuration || Configuration.new
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def open_repo(repo_name)
+      repo_conf = Repo.new(repo_name, @configuration, @logger, @gitolite_path)
+      @repos << repo_conf
+      repo_conf
+    end
+
+    def delete_repo(repo_name)
+      file_path = @configuration.repo_path(repo_name)
+      remove_file(file_path, "Deleting repo (#{repo_name}) from gitolite.")
+
+      bare_repo_path = @configuration.bare_repo_path(repo_name)
+      if File.directory?(bare_repo_path)
+        FileUtils.rm_rf bare_repo_path
+      end
+      repo_name
+    end
+
+    def open_group(group_name)
+      group_conf = UserGroup.new(group_name, @logger, @gitolite_path)
+      @user_groups << group_conf
+      group_conf
+    end
+
+    def create_user(username, rsa_pub_key, opts={})
+      key_path = @configuration.user_key_path(username)
+
+      if users_public_keys().include?(key_path)
+        raise ::Gitolite::Duplicate, "Trying to create a user (#{username}) that exists already on gitolite server"
+      end
+
+      add_commit_file(key_path,rsa_pub_key, "Added RSA public key for user '#{username}'")
+
+      key_path
+    end
+
+    def delete_user(username)
+      key_path = @configuration.user_key_path(username)
+
+      unless users_public_keys().include?(key_path)
+        raise ::Gitolite::NotFound, "User (#{username}) not found on gitolite server"
+      end
+
+      remove_file(key_path, "Removing RSA public key for user '#{username}'")
+      username
+    end
+
+    def remove_user_group(group_name)
+      group_path = @configuration.user_group_path(group_name)
+
+      unless user_group_list.include?(group_path)
+        raise ::Gitolite::NotFound, "User group (#{group_name}) not found on gitolite server"
+      end
+
+      remove_file(key_path, "Removing user group (#{group_name})")
+      group_name
+    end
+
+    def delete_user_group(group_name)
+      path = @configuration.user_group_path(group_name)
+      remove_file(path, "Remove user group (#{group_name}) from gitolite.")
+      group_name
+    end
+
+    def list_repos()
+      repo_names = repo_names_list()
+      repo_names.map { |repo_name| { :repo_name => repo_name, :type => Repo.get_repo_type(repo_name) }}
+    end
+
+    def push()
+      changed_repos  = @repos.select { |repo| repo.any_changes? }
+      changed_groups = @user_groups.select { |ug| ug.any_changes? }
+
+      unless (@commit_messages.empty? && changed_repos.empty? && changed_groups.empty?)
+        changed_repos.each  { |repo| repo.commit_changes }
+        changed_groups.each { |ug|   ug.commit_changes   }
+
+        gitolite_admin_repo().push()
+      end
+    end
+
+  private
+
+    def gitolite_admin_repo()
+      @gitolite_admin ||= Git::FileAccess.new(@gitolite_path)
+    end
+
+    def users_public_keys()
+      base_path = @configuration.keydir_path
+      list_files_in_path(base_path)
+    end
+
+    def user_group_list()
+      base_path = @configuration.user_group_path
+      list_files_in_path(base_path)
+    end
+
+    def repo_names_list()
+      base_path = @configuration.repo_path
+      repo_file_list = list_files_in_path(base_path)
+      repo_file_list.collect { |r_file_name| extract_file_name(r_file_name, base_path, :conf) }
+    end
+
+    def add_commit_file(file, content, commit_msg)
+      gitolite_admin_repo().add_file(file, content)
+      gitolite_admin_repo().commit(commit_msg)
+      @commit_messages << commit_msg
+    end
+
+    def remove_file(file_path, commit_msg)
+      gitolite_admin_repo().remove_file(file_path)
+      gitolite_admin_repo().commit(commit_msg)
+      @commit_messages << commit_msg
+    end
+
+
+    class << self
+
+      def repo_name_from_file_name(file_name, repo_file_path)
+        if file_name =~ Regexp.new("^#{repo_file_path}/(.+)\.conf")
+          $1
+        else
+          raise Error.new("File name not properly formed for repo config file name (#{file_name})")
+        end
+      end
+    end
+
+    def extract_file_name(full_path_name, file_path, file_extension)
+      if file_name =~ Regexp.new("^#{full_path_name}/(.+)\.#{file_extension}")
+        $1
+      else
+        raise ::Gitolite::ParseError.new("File name not properly formed (#{full_path_name}), expected match based on '#{file_path}/*.#{file_extension}'")
+      end
+    end
+
+    def list_files_in_path(path)
+      paths = gitolite_admin_repo.ls_r(path.split("/").size + 1, :files_only => true)
+      match_regexp = Regexp.new("^#{path}")
+      paths.select{ |p| p =~ match_regexp }
+    end
+
+  end
+end