dtk-common 0.5.11

data/lib/gitolite/repo.rb

@@ -0,0 +1,171 @@
+  # This class is used to read gitolite repo config file. File is loaded and paramters are accessible via
+  # class members. After needed manipulation class will be saved as gitolite conf file.
+
+module Gitolite
+  class Repo
+
+    include Utils
+
+    attr_accessor :repo_name, :rights_hash, :commit_messages, :user_groups, :logger
+
+    GIOLITE_ALL_GROUP = '@all' 
+
+
+    #
+    # We check if there are users in addition to tenant with line,
+    # (repo_conf.rights_hash.values.flatten.size > 1)
+    # In case no, we do not give permission to tenant even
+    #
+
+    RepoConfTemplate = ::Erubis::Eruby.new <<-eos
+    include "groups-defs/*.conf"
+    repo    <%= repo_conf.repo_name %>
+      <% if repo_conf.rights_hash.values.flatten.size > 1 %>
+        <% repo_conf.rights_hash.each do |k, v| %>
+          <% unless v.empty? %>
+            <%=k%> = <%=v.join(' ') %>
+          <% end %>
+        <% end %>
+      <% end %>
+    eos
+
+    class << self
+
+      def get_repo_type(repo_name)
+        repo_name.match(/\-\-cm\-\-/) ? 'component' : 'service'
+      end
+
+    end
+
+    def initialize(repo_name, configuration_, logger_, gitolite_path, gitolite_branch="master")
+      # IMPORTANT! Tenants user are always included with each module
+      
+      @rights_hash = { 'R' => [], 'W' => [], 'RW' => ['@tenants'], 'RW+' => []}
+      @repo_name = repo_name
+      @user_groups = []
+      @commit_messages = []
+      @repo_conf_file_path = configuration_.repo_path(repo_name)
+      @repo_dir_path       = configuration_.bare_repo_path(repo_name)
+      @gitolite_admin_repo ||= Git::FileAccess.new(gitolite_path, gitolite_branch)
+      @logger = logger_
+
+      if exists?
+        load_repo()
+      end       
+    end
+
+    def remove_username(username)
+      @rights_hash.each do |k,v|
+        if v.include?(username)
+          v.delete(username)
+          @commit_messages << "Removed access rights ('#{k}') for user/group '#{username}'"
+        end
+      end
+    end
+
+    def remove_group(group_name)
+      remove_username("@#{group_name}")
+    end
+
+    def add_username_with_rights(username, access_rights)
+      # if we get nil that means that we have to delete user from its permission stack
+      if access_rights.nil?
+        return remove_username(username)
+      end
+
+      # Only make changes if this is new user/group
+      unless @rights_hash[access_rights.upcase].include?(username)
+        remove_username(username)
+
+        @rights_hash[access_rights.upcase] << username
+        @commit_messages << "Added access rights ('#{access_rights}') for user/group '#{username}', in repo '#{@repo_name}'"
+        
+        # add to user groups if user group is added
+        if username.match(/^@/)
+          @user_groups << username
+        end
+      end
+    end
+
+    def add_user_group_with_rights(group_name, access_rights)
+      add_username_with_rights("@#{group_name}", access_rights)
+    end
+
+    def add_all_with_rights(access_rights)
+      add_username_with_rights(GIOLITE_ALL_GROUP, access_rights)
+    end
+
+    def branches
+      Git::FileAccess.new(@repo_dir_path).branches()
+    end
+
+    def exists?
+      !@gitolite_admin_repo.file_content(@repo_conf_file_path).nil?
+    end
+
+    def any_changes?
+      !@commit_messages.empty?
+    end
+
+    def commit_changes(override_commit_message = nil)
+      unless @commit_messages.empty?
+        content = file_content()
+        validate_gitolite_conf_file(content)
+
+        commit_msg = override_commit_message || @commit_messages.join(', ')
+
+        @gitolite_admin_repo.add_file(@repo_conf_file_path,content)
+        @gitolite_admin_repo.commit(commit_msg)
+
+        @logger.info(commit_msg)
+      else
+        @logger.info("There has been no changes on repo '#{@repo_name}' skipping gitolite commit.")
+      end
+    end
+
+    def file_content()
+      RepoConfTemplate.result(:repo_conf => self)
+    end
+
+  private
+
+    def load_repo()
+      raw_content = @gitolite_admin_repo.file_content(@repo_conf_file_path)
+
+      unless raw_content
+        raise ::Error::NotFound, "Configuration file for repo (#{repo_name}) does not exist"
+      end
+
+      raw_content.each_line do |l|
+        l.chomp!()
+        if l =~ /^[ ]*repo[ ]+([^ ]+)/
+          unless $1 == repo_name
+            raise Error::GitoliteParsing, "Parsing error: expected repo to be (${repo_name} in (#{l})"
+          end
+        elsif l =~ /[ ]*([^ ]+)[ ]*=[ ]*(.+)$/
+          access_rights = $1
+          users = $2
+          users.scan(/[^ ]+/) do |user|
+            unless access_rights.match(/R|W|RW|RW+/)
+              raise  Error::GitoliteParsing, "Unexpected access rights while parsing file '#{access_rights}'"
+            end
+
+            @rights_hash[access_rights.to_s] << user unless @rights_hash[access_rights.to_s].include?(user)
+
+            # add to user groups if present
+            if user.match(/^@/)
+              @user_groups << user
+            end
+          end
+        elsif l.strip.empty? || l.strip().match(/^include/)
+          #no op
+        else
+          raise ::Error::GitoliteParsing, "Parsing repo error: (#{l})"
+        end
+      end
+    end
+
+
+  end
+
+end

data/lib/gitolite/user_group.rb

@@ -0,0 +1,98 @@
+module Gitolite
+  class UserGroup
+
+    include Utils
+
+    GROUP_CONFIG_PATH = 'conf/group-defs'
+    # we need this to make sure that group is there but dummy name is needed to pass gitolite check
+    # DUMMY_USERNAME = 'r8_dummy_group_user'
+
+    UserGroupTemplate = Erubis::Eruby.new <<-eos
+      @<%=user_group.name%> = <%= user_group.members.empty? ? 'r8_dummy_group_user' : user_group.members.join(' ') %>
+    eos
+
+    attr_accessor :name, :members, :logger
+
+    def initialize(group_name, logger_, gitolite_path, gitolite_branch = "master")
+      @name    = group_name
+      @members = []
+      @commit_messages = []
+      @group_file_path = File.join(GROUP_CONFIG_PATH, "#{@name}.conf")
+      @gitolite_admin_repo ||= Git::FileAccess.new(gitolite_path, gitolite_branch)
+      @logger = logger_
+
+      if exists?
+        load_group()
+      end
+    end
+
+    def load_group()
+      raw_content = @gitolite_admin_repo.file_content(@group_file_path)
+
+      unless raw_content
+        raise Gitolite::NotFound, "Configuration file for user group (#{@name}) does not exist"
+      end
+
+      raw_content.each_line do |l|
+        l.chomp!()
+        if l =~ /.*=(.+)$/
+          raw_members = $1
+          @members = raw_members.chomp().split(' ')
+        else
+          raise ::Error::GitoliteParsing, "Parsing groups error: (#{l})"
+        end
+      end
+    end
+
+    def exists?
+      !@gitolite_admin_repo.file_content(@group_file_path).nil?
+    end
+
+    def any_changes?
+      !@commit_messages.empty?
+    end
+
+    def add_git_usernames(array_of_usernames)
+      unless is_subset?(@members, array_of_usernames)
+        @members.concat(array_of_usernames)
+        @members.uniq!
+        @commit_messages << "Added users (#{array_of_usernames.join(', ')}) to group '#{@name}'"
+      end
+    end
+
+    def set_git_usernames(array_of_usernames)
+      # we clean current member since we are setting all gitusernames (not adding)
+      @members = []
+      add_git_usernames(array_of_usernames)
+    end
+
+    def remove_git_usernames(array_of_usernames)
+      if is_subset?(@members, array_of_usernames)
+        @members = @members - array_of_usernames
+        @commit_messages << "Removed users (#{array_of_usernames.join(', ')}) from group '#{@name}'"  
+      end
+    end
+
+    def commit_changes(override_commit_message = nil)
+      # we check if there were changes
+      unless @commit_messages.empty?
+        content = file_content()
+
+        commit_msg = override_commit_message || @commit_messages.join(', ')
+
+        @gitolite_admin_repo.add_file(@group_file_path,content)
+        @gitolite_admin_repo.commit(commit_msg)
+        
+        @logger.info(commit_msg)
+      else
+        @logger.info("There has been no changes on group '#{@name}' skipping gitolite commit.")
+      end
+    end
+
+
+    def file_content()
+      UserGroupTemplate.result(:user_group => self)
+    end
+
+  end
+end

data/lib/gitolite/utils.rb

@@ -0,0 +1,59 @@
+module Gitolite
+  module Utils
+    def validate_gitolite_conf_file(content)
+      # first line that is not empty
+      first_line = true
+
+      content.split(/\n|\r/).each_with_index do |line, i|
+        next if line.strip().empty?
+        next if line.strip().match(/^include/)
+
+        if first_line
+          raise_gitolite_error("Gitolite conf repo header is not valid", content) unless line.match(/repo *[a-zA-Z\-0-9]+/)
+          first_line = !first_line
+          next
+        end
+
+        # line must start with R/W/RW+
+        raise_gitolite_error("Gitolite conf repo line must start with R/RW/W(+)", content) unless line.match(/^ *(R|W|RW)\+? *=/m)
+
+        # must be matched only once
+        raise_gitolite_error("Gitolite conf repo line must containt ONLY one entry of R/RW/W(+)=", content) if line.scan(/(R|W|RW)\+? *=/).size > 1
+      end
+
+      return content
+    end
+
+    def raise_gitolite_error(msg, content)
+      Rails.logger.debug "Gitolite validation failed with: #{msg}"
+      Rails.logger.debug content
+      raise ::Error::GitoliteValidation.new(msg)
+    end
+
+    #
+    # Checks to see if array2 is subset of array1
+    #
+    def is_subset?(array1, array2)
+      result = array1 & array2
+      (array2.length == result.length)
+    end
+
+    #
+    # Converts permission to gitolite friendly permission
+    # 
+    def gitolite_friendly(permission)
+      if permission.empty?
+        return nil
+      elsif permission.match(/^RWDP?/)
+        return "RW+"
+      elsif permission.match(/^RW/)
+        return "RW"
+      elsif permission.match(/^R/)
+        return 'R'
+      else
+        raise ::Error::NotSupported, "Not supported permission '#{permission}'!"
+      end
+    end
+
+  end
+end

data/lib/grit_adapter/file_access/diff.rb

@@ -0,0 +1,82 @@
+class DTK::Common::GritAdapter::FileAccess
+  module DiffMixin
+    def diff(*args)
+      diff_comamnd_args = 
+        case args.size
+         when 1 then [@branch,args[0]]
+         when 2 then args
+          else raise Error.new("diff must have 1 or 2 arguments")
+        end
+      grit_diffs = @grit_repo.diff(*diff_comamnd_args)
+      array_diff_hashes = grit_diffs.map do |diff|
+        Diff::Attributes.inject(Hash.new) do |h,a|
+          val = diff.send(a)
+          val ?  h.merge(a => val) : h
+        end
+      end
+      Diffs.new(array_diff_hashes)
+    end
+
+    class Diffs < Array
+      
+      class Summary < ::DTK::Common::SimpleHashObject
+        def any_diffs?()
+          !keys().empty?
+        end
+        def any_added_or_deleted_files?()
+          !!(self[:files_renamed] or self[:files_added] or self[:files_deleted])
+        end
+        
+        def meta_file_changed?()
+          self[:files_modified] and !!self[:files_modified].find{|r|r[:path] =~ /^r8meta/}
+        end
+
+        #note: in paths_to_add and paths_to_delete rename appears both since rename can be accomplsihed by a add + a delete 
+        def paths_to_add()
+          (self[:files_added]||[]).map{|r|r[:path]} + (self[:files_renamed]||[]).map{|r|r[:new_path]}
+        end
+        def paths_to_delete()
+          (self[:files_deleted]||[]).map{|r|r[:path]} + (self[:files_renamed]||[]).map{|r|r[:old_path]}
+        end
+      end
+      
+      def initialize(array_diff_hashes)
+        super(array_diff_hashes.map{|hash|Diff.new(hash)})
+      end
+
+      #returns a hash with keys :file_renamed, :file_added, :file_deleted, :file_modified
+      def ret_summary()
+        [:renamed,:added,:deleted,:modified].inject(Summary.new) do |h,cnd|
+          res = map{|diff|diff.send("file_#{cnd}".to_sym)}.compact
+          res.empty? ? h : h.merge("files_#{cnd}".to_sym => res)
+        end
+      end
+    end
+
+    class Diff
+      Attributes = [:new_file,:renamed_file,:deleted_file,:a_path,:b_path,:diff]
+      AttributeAssignFn = Attributes.inject(Hash.new){|h,a|h.merge(a => "#{a}=".to_sym)}
+      def initialize(hash_input)
+        hash_input.each{|a,v|send(AttributeAssignFn[a],v)}
+      end
+      
+      def file_added()
+        @new_file && {:path => @a_path}
+      end
+
+      def file_renamed()
+        @renamed_file && {:old_path => @b_path, :new_path => @a_path}
+      end
+
+      def file_deleted()
+        @deleted_file && {:path => @a_path}
+      end
+
+      def file_modified()
+        ((@new_file or @deleted_file or @renamed_file) ? nil : true) && {:path => @a_path} 
+      end
+     private
+      attr_writer(*Attributes) 
+    end
+  end
+end

data/lib/grit_adapter/file_access/status.rb

@@ -0,0 +1,25 @@
+module DTK::Common; class GritAdapter; class FileAccess
+  module StatusMixin
+    def status()
+      chdir_and_checkout do
+        Status.new(@grit_repo.status)
+      end
+    end
+
+    class Status < Hash
+      def initialize(grit_status_obj)
+        super()
+        FileStates.each do |file_state|
+          paths_with_file_state = grit_status_obj.send(file_state).map{|info|info[1].path} 
+          self[file_state] = paths_with_file_state unless paths_with_file_state.empty?
+        end
+      end
+      
+      def any_changes?()
+        !!FileStates.find{|fs|self[fs]}
+      end
+      
+      FileStates = [:added,:deleted,:changed,:untracked]
+    end
+  end                                         
+end; end; end