gitolite-rugged 1.2.pre.devel

data/lib/gitolite/config.rb

@@ -0,0 +1,284 @@
+require 'tempfile'
+
+module Gitolite
+
+  class Config
+
+    attr_accessor :repos, :groups, :filename
+
+    def self.init(filename = "gitolite.conf")
+      file = Tempfile.new(filename)
+      conf = self.new(file.path)
+      conf.filename = filename #kill suffix added by Tempfile
+      file.close(unlink_now = true)
+      conf
+    end
+
+
+    def initialize(config)
+      @repos = {}
+      @groups = {}
+      @filename = File.basename(config)
+      process_config(config)
+    end
+
+
+    # TODO: merge repo unless overwrite = true
+    def add_repo(repo, overwrite = false)
+      raise ArgumentError, "Repo must be of type Gitolite::Config::Repo!" unless repo.instance_of? Gitolite::Config::Repo
+      @repos[repo.name] = repo
+    end
+
+
+    def rm_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos.delete(name)
+    end
+
+
+    def has_repo?(repo)
+      name = normalize_repo_name(repo)
+      @repos.has_key?(name)
+    end
+
+
+    def get_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos[name]
+    end
+
+
+    def add_group(group, overwrite = false)
+      raise ArgumentError, "Group must be of type Gitolite::Config::Group!" unless group.instance_of? Gitolite::Config::Group
+      @groups[group.name] = group
+    end
+
+
+    def rm_group(group)
+      name = normalize_group_name(group)
+      @groups.delete(name)
+    end
+
+
+    def has_group?(group)
+      name = normalize_group_name(group)
+      @groups.has_key?(name)
+    end
+
+
+    def get_group(group)
+      name = normalize_group_name(group)
+      @groups[name]
+    end
+
+
+    def to_file(path=".", filename=@filename)
+      raise ArgumentError, "Path contains a filename or does not exist" unless File.directory?(path)
+
+      new_conf = File.join(path, filename)
+      File.open(new_conf, "w") do |f|
+        f.sync = true
+
+        # Output groups
+        dep_order = build_groups_depgraph
+        dep_order.each {|group| f.write group.to_s }
+
+        gitweb_descs = []
+        @repos.sort.each do |k, v|
+          f.write "\n"
+          f.write v.to_s
+
+          gwd = v.gitweb_description
+          gitweb_descs.push(gwd) unless gwd.nil?
+        end
+
+        f.write "\n"
+        f.write gitweb_descs.join("\n")
+      end
+
+      new_conf
+    end
+
+
+    private
+
+
+    # Based on
+    # https://github.com/sitaramc/gitolite/blob/pu/src/gl-compile-conf#cleanup_conf_line
+    def cleanup_config_line(line)
+      # remove comments, even those that happen inline
+      line.gsub!(/^((".*?"|[^#"])*)#.*/) {|m| m=$1}
+
+      # fix whitespace
+      line.gsub!('=', ' = ')
+      line.gsub!(/\s+/, ' ')
+      line.strip
+    end
+
+
+    def process_config(config)
+      context = [] #will store our context for permissions or config declarations
+
+      #Read each line of our config
+      File.open(config, 'r').each do |l|
+
+        line = cleanup_config_line(l)
+        next if line.empty? #lines are empty if we killed a comment
+
+        case line
+
+          # found a repo definition
+          when /^repo (.*)/
+            #Empty our current context
+            context = []
+
+            repos = $1.split
+            repos.each do |r|
+              context << r
+
+              @repos[r] = Repo.new(r) unless has_repo?(r)
+            end
+
+          # repo permissions
+          when /^(-|C|R|RW\+?(?:C?D?|D?C?)M?) (.* )?= (.+)/
+            perm = $1
+            refex = $2 || ""
+            users = $3.split
+
+            context.each do |c|
+              @repos[c].add_permission(perm, refex, users)
+            end
+
+          # repo git config
+          when /^config (.+) = ?(.*)/
+            key = $1
+            value = $2
+
+            context.each do |c|
+              @repos[c].set_git_config(key, value)
+            end
+
+          # repo gitolite option
+          when /^option (.+) = (.*)/
+            key = $1
+            value = $2
+
+            raise ParseError, "Missing gitolite option value for repo: #{repo} and key: #{key}" if value.nil?
+
+            context.each do |c|
+              @repos[c].set_gitolite_option(key, value)
+            end
+
+          # group definition
+          when /^#{Group::PREPEND_CHAR}(\S+) = ?(.*)/
+            group = $1
+            users = $2.split
+
+            @groups[group] = Group.new(group) unless has_group?(group)
+            @groups[group].add_users(users)
+
+          # gitweb definition
+          when /^(\S+)(?: "(.*?)")? = "(.*)"$/
+            repo = $1
+            owner = $2
+            description = $3
+
+            #Check for missing description
+            raise ParseError, "Missing Gitweb description for repo: #{repo}" if description.nil?
+
+            #Check for groups
+            raise ParseError, "Gitweb descriptions cannot be set for groups" if repo =~ /@.+/
+
+            if has_repo? repo
+              r = @repos[repo]
+            else
+              r = Repo.new(repo)
+              add_repo(r)
+            end
+
+            r.owner = owner
+            r.description = description
+
+          when /^include "(.+)"/
+            #TODO: implement includes
+            #ignore includes for now
+
+          when /^subconf (\S+)$/
+            #TODO: implement subconfs
+            #ignore subconfs for now
+
+          else
+            raise ParseError, "'#{line}' cannot be processed"
+        end
+      end
+    end
+
+
+    # Normalizes the various different input objects to Strings
+    def normalize_name(context, constant = nil)
+      case context
+        when constant
+          context.name
+        when Symbol
+          context.to_s
+        else
+          context
+      end
+    end
+
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /normalize_(\w+)_name/
+        # Could use Object.const_get to figure out the constant here
+        # but for only two cases, this is more readable
+        case $1
+          when "repo"
+            normalize_name(args[0], Gitolite::Config::Repo)
+          when "group"
+            normalize_name(args[0], Gitolite::Config::Group)
+        end
+      else
+        super
+      end
+    end
+
+
+    # Builds a dependency tree from the groups in order to ensure all groups
+    # are defined before they are used
+    def build_groups_depgraph
+      dp = ::GRATR::Digraph.new
+
+      # Add each group to the graph
+      @groups.each_value do |group|
+        dp.add_vertex! group
+
+        # Select group names from the users
+        subgroups = group.users.select {|u| u =~ /^#{Group::PREPEND_CHAR}.*$/}.map{|g| get_group g.gsub(Group::PREPEND_CHAR, '') }
+
+        subgroups.each do |subgroup|
+          dp.add_edge! subgroup, group
+        end
+      end
+
+      # Figure out if we have a good depedency graph
+      dep_order = dp.topsort
+
+      if dep_order.empty?
+        raise GroupDependencyError unless @groups.empty?
+      end
+
+      dep_order
+    end
+
+
+    #Raised when something in a config fails to parse properly
+    class ParseError < RuntimeError
+    end
+
+
+    # Raised when group dependencies cannot be suitably resolved for output
+    class GroupDependencyError < RuntimeError
+    end
+
+  end
+end

data/lib/gitolite/dirty_proxy.rb

@@ -0,0 +1,32 @@
+module Gitolite
+
+  # Very simple proxy object for checking if the proxied object was modified
+  # since the last clean_up! method called. It works correctly only for objects
+  # with proper hash method!
+
+  class DirtyProxy < BasicObject
+
+    def initialize(target)
+      @target = target
+      clean_up!
+    end
+
+    def method_missing(method, *args, &block)
+      @target.send(method, *args, &block)
+    end
+
+    def respond_to?(symbol, include_private=false)
+      super || [:dirty?, :clean_up!].include?(symbol.to_sym)
+    end
+
+    def dirty?
+      @clean_hash != @target.hash
+    end
+
+    def clean_up!
+      @clean_hash = @target.hash
+    end
+
+  end
+
+end

data/lib/gitolite/gitolite_admin.rb

@@ -0,0 +1,276 @@
+module Gitolite
+  class GitoliteAdmin
+
+    attr_accessor :repo
+
+    CONF_DIR    = "conf"
+    KEY_DIR     = "keydir"
+
+    CONFIG_FILE = "gitolite.conf"
+    CONFIG_PATH = File.join(CONF_DIR, "gitolite.conf")
+
+
+    # Default settings
+    DEFAULT_SETTINGS = {
+      # clone/push url settings
+      git_user: 'git', 
+      hostname: 'localhost',
+
+      # Commit settings
+      author_name: 'gitolite-rugged gem',
+      author_email: 'gitolite-rugged@localhost',
+      commit_msg: 'Commited by the gitolite-rugged gem'
+    }
+
+    class << self
+
+      # Checks if the given path is a gitolite-admin repository
+      # A valid repository contains a conf folder, keydir folder,
+      # and a configuration file within the conf folder
+      def is_gitolite_admin_repo?(dir)
+        # First check if it is a git repository
+        begin
+          repo = Rugged::Repository.new(dir)
+          return false if repo.empty?
+        rescue Rugged::RepositoryError
+          return false
+        end
+
+        # Check if config file, key directory exist
+        [ File.join(dir, CONF_DIR), File.join(dir, KEY_DIR),
+          File.join(dir, CONFIG_PATH)
+        ].each { |f| return false unless File.exists?(f) }
+
+        true
+      end
+
+      def admin_url(settings)
+        [settings[:git_user], '@', settings[:host], '/gitolite-admin.git'].join
+      end
+    end
+
+    # Intialize with the path to
+    # the gitolite-admin repository
+    #
+    # Settings:
+    # :git_user: The git user to SSH to (:git_user@localhost:gitolite-admin.git), defaults to 'git'
+    # :private_key: The key file containing the private SSH key for :git_user
+    # :public_key: The key file containing the public SSH key for :git_user
+    # :host: Hostname for clone url. Defaults to 'localhost'
+    # The settings hash is forwarded to +GitoliteAdmin.new+ as options.
+    def initialize(path, settings = {})
+      @path = path
+      @settings = DEFAULT_SETTINGS.merge(settings)
+
+      # Ensure SSH key settings exist
+      @settings.fetch(:public_key)
+      @settings.fetch(:private_key)
+
+      # setup credentials
+      @credentials = Rugged::Credentials::SshKey.new(
+        username: settings[:git_user], publickey: settings[:public_key], 
+        privatekey: settings[:private_key] )
+      
+      @repo = 
+      if self.class.is_gitolite_admin_repo?(path)
+        Rugged::Repository.new(path)
+      else
+        clone
+      end
+
+      @config_file_path = File.join(@path, CONF_DIR, CONFIG_FILE)
+      @conf_dir_path    = File.join(@path, CONF_DIR)
+      @key_dir_path     = File.join(@path, KEY_DIR)
+
+      @commit_author = { email: settings[:author_email], name: settings[:author_name] }
+
+      reload!
+    end
+
+    def config
+      @config ||= load_config
+    end
+
+
+    def config=(config)
+      @config = config
+    end
+
+
+    def ssh_keys
+      @ssh_keys ||= load_keys
+    end
+
+
+    def add_key(key)
+      unless key.instance_of? Gitolite::SSHKey
+        raise GitoliteAdminError, "Key must be of type Gitolite::SSHKey!"
+      end
+
+      ssh_keys[key.owner] << key
+    end
+
+
+    def rm_key(key)
+      unless key.instance_of? Gitolite::SSHKey
+        raise GitoliteAdminError, "Key must be of type Gitolite::SSHKey!"
+      end
+
+      ssh_keys[key.owner].delete key
+    end
+
+
+    # This method will destroy all local tracked changes, resetting the local gitolite
+    # git repo to HEAD and reloading the entire repository
+    def reset!
+      @repo.reset('origin/master', :hard)
+      reload!
+    end
+
+
+    # This method will destroy the in-memory data structures and reload everything
+    # from the file system
+    def reload!
+      @ssh_keys = load_keys
+      @config = load_config
+    end
+
+
+    # Writes all changed aspects out to the file system
+    # will also stage all changes then commit
+    def save()
+
+      # Add all changes to index (staging area)
+      index = @repo.index
+
+      #Process config file (if loaded, i.e. may be modified)
+      if @config
+        new_conf = @config.to_file(@conf_dir_path)
+
+        # Rugged wants relative paths
+        index.add(CONFIG_PATH)
+      end
+
+      #Process ssh keys (if loaded, i.e. may be modified)
+      if @ssh_keys
+        files = list_keys.map{|f| File.basename f}
+        keys  = @ssh_keys.values.map{|f| f.map {|t| t.filename}}.flatten
+
+        to_remove = (files - keys).map { |f| File.join(@key_dir, f) }
+        to_remove.each do |key|
+          File.unlink key
+          index.remove key
+        end
+
+        @ssh_keys.each_value do |key|
+          # Write only keys from sets that has been modified
+          next if key.respond_to?(:dirty?) && !key.dirty?
+          key.each do |k|
+            new_key = k.to_file(@key_dir_path)
+            index.add new_key
+          end
+        end
+      end
+
+      # Write index to git and resync fs
+      commit_tree = index.write_tree @repo
+      index.write
+
+      commit_author = { email: 'wee@example.org', name: 'gitolite-rugged gem', time: Time.now }
+
+      Rugged::Commit.create(@repo,
+        author: commit_author,
+        committer: commit_author,
+        message: @settings[:commit_msg],
+        parents: [repo.head.target],
+        tree: commit_tree,
+        update_ref: 'HEAD'
+      )
+    end
+
+
+    # Push back to origin
+    def apply
+      @repo.push 'origin', ['refs/heads/master']
+    end
+
+
+    # Commits all staged changes and pushes back to origin
+    def save_and_apply()
+      save
+      apply
+    end
+
+
+    # Updates the repo with changes from remote master
+    # Warning: This resets the repo before pulling in the changes.
+    def update(settings = {})
+      reset!
+
+      # Currently, this only supports merging origin/master into master.
+      master = repo.branches["master"].target
+      origin_master = repo.branches["origin/master"].target
+
+      # Create the merged index in memory
+      merge_index = repo.merge_commits(master, origin_master)
+
+      # Complete the merge by comitting it
+      merge_commit = Rugged::Commit.create(@repo, 
+        parents: [ master, origin_master ],
+        tree: merge_index.write_tree(@repo),
+        message: '[gitolite-rugged] Merged `origin/master` into `master`',
+        author: @commit_author,
+        committer: @commit_author,
+        update_ref: 'master'
+      )
+
+      reload!
+    end
+
+
+    private
+
+
+    # Clone the gitolite-admin repo
+    # to the given path.  
+    # 
+    # The repo is cloned from the url
+    # +(:git_user)@(:hostname)/gitolite-admin.git+
+    #
+    # The hostname may use an optional :port to allow for custom SSH ports.
+    # E.g., +git@localhost:2222/gitolite-admin.git+
+    #
+    def clone()
+      Rugged::Repository.clone_at(admin_url(@settings), File.expand_path(@path), credentials: @creds)
+    end    
+
+
+    def load_config
+      Config.new(@config_file_path)
+    end
+
+
+    def list_keys
+      Dir.glob(@key_dir_path + '/**/*.pub')
+    end
+
+
+    # Loads all .pub files in the gitolite-admin
+    # keydir directory
+    def load_keys
+      keys = Hash.new {|k,v| k[v] = DirtyProxy.new([])}
+
+      list_keys.each do |key|
+        new_key = SSHKey.from_file(key)
+        owner = new_key.owner
+
+        keys[owner] << new_key
+      end
+
+      # Mark key sets as unmodified (for dirty checking)
+      keys.values.each{|set| set.clean_up!}
+
+      keys
+    end
+  end
+end

data/lib/gitolite/ssh_key.rb

@@ -0,0 +1,103 @@
+module Gitolite
+
+  # Models an SSH key within gitolite
+  # provides support for multikeys
+  #
+  # Types of multi keys:
+  #   bob.pub => username: bob
+  #   bob@desktop.pub => username: bob, location: desktop
+  #   bob@email.com.pub => username: bob@email.com
+  #   bob@email.com@desktop.pub => username: bob@email.com, location: desktop
+
+  class SSHKey
+
+    attr_accessor :owner, :location, :type, :blob, :email
+
+    class << self
+
+      def from_file(key)
+        raise "#{key} does not exist!" unless File.exists?(key)
+
+        # TODO this is old-style locations, use folders instead.
+        # Get our owner and location
+        File.basename(key) =~ /^([\+\w\.-]+(?:@(?:[\w-]+\.)+\D{2,4})?)(?:@([\w-]+))?.pub$/i
+        owner    = $1
+        location = $2 || ""
+
+        # Use string key constructor
+        self.from_string(File.read(key), owner, location)
+      end
+
+
+      # Construct a SSHKey from a string
+      def from_string(key_string, owner, location = "")
+        if owner.nil?
+          raise ArgumentError, "owner was nil, you must specify an owner"
+        end
+
+        # Get parts of the key
+        type, blob, email = key_string.split
+
+        # We need at least a type or blob
+        if type.nil? || blob.nil?
+          raise ArgumentError, "'#{key_string}' is not a valid SSH key string"
+        end
+
+        # If the key didn't have an email, just use the owner
+        if email.nil?
+          email = owner
+        end
+
+        self.new(type, blob, email, owner, location)
+      end
+
+    end
+
+
+    def initialize(type, blob, email, owner = nil, location = "")
+      @type = type
+      @blob = blob
+      @email = email
+
+      @owner = owner || email
+      @location = location
+    end
+
+
+    def to_s
+      [@type, @blob, @email].join(' ')
+    end
+
+
+    def to_file(path)
+      key_file = File.join(path, self.filename)
+      File.open(key_file, "w") do |f|
+        f.sync = true
+        f.write(self.to_s)
+      end
+      key_file
+    end
+
+
+    def filename
+      file = @owner
+      file += "@#{@location}" unless @location.empty?
+      file += ".pub"
+    end
+
+
+    def ==(key)
+      @type == key.type &&
+      @blob == key.blob &&
+      @email == key.email &&
+      @owner == key.owner &&
+      @location == key.location
+    end
+
+
+    def hash
+      [@owner, @location, @type, @blob, @email].hash
+    end
+
+  end
+end

data/lib/gitolite/version.rb

@@ -0,0 +1,3 @@
+module Gitolite
+  VERSION = "1.2-devel"
+end

data/lib/gitolite.rb

@@ -0,0 +1,10 @@
+module Gitolite
+  require 'rugged'
+  require 'gratr'
+  require 'gitolite/gitolite_admin'
+  require 'gitolite/dirty_proxy'
+  require 'gitolite/ssh_key'
+  require 'gitolite/config'
+  require 'gitolite/config/repo'
+  require 'gitolite/config/group'
+end