git-maintain 0.12.0 → 0.14.2

data/lib/git-maintain/branch_iterator.rb

@@ -0,0 +1,148 @@
+# Main module for git-maintain repository maintenance tool.
+module GitMaintain
+
+    # Iterator class. List all the branch specific actions and trigger  that action on all relevant branches
+    class BranchIterator < Common
+
+        begin
+            const_set(:EXTENDED_CLASS, GitMaintain::getExtendedClass(Branch))
+        rescue RunError
+            const_set(:EXTENDED_CLASS, Branch)
+        end
+
+        # List of all available maintenance actions.
+        [:ACTION_LIST, :NO_FETCH_ACTIONS, :NO_CHECKOUT_ACTIONS,
+         :ALL_BRANCHES_ACTIONS, :ACTION_HELP].each() do |field|
+            const_set(field, EXTENDED_CLASS.const_get(field))
+        end
+
+
+        # Configure action-specific command line options.
+        #
+        # @param action [Symbol] Selected action name
+        # @param optsParser [OptionParser] The OptionParser instance to configure
+        # @param opts [Hash] The options hash to populate
+        def self.set_opts(action, optsParser, opts)
+            Branch.set_opts(action, optsParser, opts)
+            if EXTENDED_CLASS != Branch && EXTENDED_CLASS.respond_to?(:set_opts)
+                EXTENDED_CLASS.set_opts(action, optsParser, opts)
+            end
+        end
+
+        # Sanity check and normalize the parsed options for the given action.
+        #
+        # @param opts [Hash] Options hash to validate and configure
+        # @raise [InvalidArgumentError] If options are invalid or conflicting
+        def self.check_opts(opts)
+            Branch.check_opts(opts)
+            if EXTENDED_CLASS != Branch && EXTENDED_CLASS.respond_to?(:check_opts)
+                EXTENDED_CLASS.check_opts(opts)
+            end
+        end
+
+        # Initialize the BranchIterator instance
+        def initialize()
+            @repo   = Repo::load()
+            @ci     = CI::load(@repo)
+        end
+        # Define wrappers for all actions, each calling iterateAction
+        ACTION_LIST.each do |action|
+            define_method(action) do |opts|
+                iterateAction(opts, action)
+            end
+        end
+
+        private
+        # Execute the specified action on the selected branch(es).
+        # Loads the repo, targets branches, iterates through them, and runs any action epilogue.
+        #
+        # @param opts [Hash] Options hash
+        # @param action [Symbol] Action name to execute
+        # @raise [GitMaintainError] If executing the action fails
+        def iterateAction(opts, action)
+            opts[:repo] = @repo
+            opts[:ci] = @ci
+
+            if NO_FETCH_ACTIONS.index(action) == nil && opts[:fetch] != false then
+                log(:INFO, "Fetching stable repo")
+                @repo.stableUpdate(opts[:fetch])
+            end
+
+            branches = getBranchList(opts, action)
+
+            if opts[:watch] == false
+                # One shot run
+                runOnBranches(opts, action, branches)
+                log(:INFO, "Done working on selected branches")
+                return
+            end
+
+            # Watch style action
+            loop do
+                # Timestamp on top, 'watch' style
+                system("clear; date")
+
+                runOnBranches(opts, action, branches)
+
+                sleep(opts[:watch])
+                @ci.emptyCache()
+            end
+            # No need for a log message here, the only exit condition
+            # is a Ctr-C that trigger an exception
+        end
+
+
+        # List the branches the iterator should loop on
+        # This can either be manually specified, or filtered by user or some specific command
+        #
+        # @param opts [Hash] Options hash
+        # @param action [Symbol] Action name to execute
+        # @return [Array<Branch>] Array of relevant branches
+        def getBranchList(opts, action)
+            # Direct branch selection
+            if opts[:manual_branch] != nil then
+                return [ Branch::load(@repo, opts[:manual_branch], @ci, opts[:br_suff]) ]
+            end
+
+            unfilteredList = nil
+            if ALL_BRANCHES_ACTIONS.index(action) != nil then
+                unfilteredList = @repo.getStableBranchList()
+            else
+                unfilteredList = @repo.getBranchList(opts[:br_suff])
+            end
+
+            return unfilteredList.map(){|br|
+                    branch = Branch::load(@repo, br, @ci, opts[:br_suff])
+                    case branch.is_targetted?(opts)
+                    when :too_old
+                        log(:VERBOSE, "Skipping older v#{branch.version}")
+                        next
+                    when :no_match
+                        log(:VERBOSE, "Skipping v#{branch.version} not matching" +
+                                      opts[:version].to_s())
+                        next
+                    end
+                    branch
+                }.compact()
+        end
+
+        def runOnBranches(opts, action, branches)
+            res=[]
+
+            # Iterate concerned on all branches
+            branches.each(){|branch|
+                if NO_CHECKOUT_ACTIONS.index(action) == nil  then
+                    log(:INFO, "Working on #{branch.verbose_name}")
+                    branch.checkout()
+                end
+                res << branch.send(action, opts)
+            }
+
+            # Run epilogue (if it exists)
+            # Use the first branch to run it so we have an existing Object
+            if branches[0].respond_to?((action.to_s() + "_epilogue").to_sym())
+                branches[0].public_send(action.to_s() + "_epilogue", opts, res)
+            end
+        end
+    end
+end

data/lib/git-maintain/ci.rb

@@ -0,0 +1,163 @@
+# Main module for git-maintain repository maintenance tool.
+module GitMaintain
+    # Abstract base class for CI provider adapters (e.g. TravisCI, AzureCI).
+    class CI < Common
+
+        # Factory method to load an instance of the CI class or its repository-specific subclass.
+        #
+        # @param repo [Repo] The Repo instance
+        # @return [CI] The loaded CI instance (or subclass)
+        # @raise [GitMaintainError] If class loading fails
+        def self.load(repo)
+            repo_name = File.basename(repo.path)
+            return GitMaintain::loadClass(CI, repo_name, repo)
+        end
+
+        # Initialize the CI instance.
+        #
+        # @param repo [Repo] The Repo instance
+        def initialize(repo)
+            GitMaintain::checkDirectConstructor(self.class)
+
+            @repo = repo
+            @cachedJson={}
+        end
+
+        private
+
+        # Fetch HTTP response from the specified URI string, following redirects up to the limit.
+        #
+        # @param uri_str [String, URI] The URI to fetch
+        # @param limit [Integer] Redirect follow limit
+        # @return [Net::HTTPResponse] The HTTP response object
+        # @raise [ArgumentError] If HTTP redirects exceed limit
+        def fetch(uri_str, limit = 10)
+            # You should choose a better exception.
+            raise ArgumentError, 'too many HTTP redirects' if limit == 0
+
+            response = Net::HTTP.get_response(URI(uri_str))
+
+            case response
+            when Net::HTTPSuccess then
+                response
+            when Net::HTTPRedirection then
+                location = response['location']
+                fetch(location, limit - 1)
+            else
+                response.value
+            end
+        end
+
+        # Retrieve JSON data (or raw body) from a CI query URL, with local caching.
+        #
+        # @param base_url [String] Base API/URL
+        # @param query_label [Symbol] Query label used for caching
+        # @param query [String] Query path
+        # @param json [Boolean] True to parse response body as JSON
+        # @return [Hash, String] The fetched JSON payload or raw body string
+        # @raise [GitMaintainError] If the HTTP request fails
+        def getJson(base_url, query_label, query, json=true)
+            return @cachedJson[query_label] if @cachedJson[query_label] != nil
+            url = base_url + query
+            uri = URI(url)
+            log(:INFO, "Querying CI...")
+            log(:DEBUG_CI, url)
+            response = fetch(uri)
+            raise GitMaintainError.new("CI request failed '#{url}'") if response.code.to_s() != '200'
+
+            if json == true
+                @cachedJson[query_label] = JSON.parse(response.body)
+            else
+                @cachedJson[query_label] = response.body
+            end
+            return @cachedJson[query_label]
+        end
+
+        public
+        # Retrieve the validation build state for a specific branch and commit.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build status string (e.g. 'passed')
+        def getValidState(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Check if the validation build is successful.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [Boolean] True if build passed
+        def checkValidState(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Retrieve the validation build log.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build log output text
+        def getValidLog(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Retrieve the validation build timestamp.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build timestamp
+        def getValidTS(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Retrieve the stable build state for a specific branch and commit.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build status string
+        def getStableState(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Check if the stable build is successful.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [Boolean] True if build passed
+        def checkStableState(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Retrieve the stable build log.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build log output text
+        def getStableLog(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Retrieve the stable build timestamp.
+        #
+        # @param br [Branch] The Branch instance
+        # @param sha1 [String] Commit SHA
+        # @return [String] Build timestamp
+        def getStableTS(br, sha1)
+            raise("Unimplemented")
+        end
+
+        # Clear local JSON request cache.
+        def emptyCache()
+            @cachedJson={}
+        end
+
+        # Check if the CI build status represents an error/failure.
+        #
+        # @param br [Branch] The Branch instance
+        # @param status [String] CI status string
+        # @return [Boolean] True if build errored or failed
+        def isErrored(br, status)
+            raise("Unimplemented")
+        end
+    end
+end

data/lib/git-maintain/common.rb

@@ -0,0 +1,117 @@
+require 'cli_class_tool'
+
+# Main module for git-maintain repository maintenance tool.
+module GitMaintain
+    extend CLIClassTool::Utils
+    # Provide module-level log() for use from class methods (e.g. self.check_opts)
+    extend CLIClassTool::Logger
+
+    # Base class for git-maintain components providing generic logging and CLI utility helpers.
+    class Common < CLIClassTool::Common
+        public :log
+
+        # Log an error message and raise a GitMaintainError.
+        #
+        # @param msg [String] Error message
+        # @raise [GitMaintainError] Always raised with the given message
+        def crit(msg)
+            log(:ERROR, msg)
+            raise GitMaintainError.new(msg)
+        end
+
+    end
+
+    # Internal registry for custom repo-specific adapters.
+    @@custom_classes = {}
+
+    # Internal cached repo path and name
+    @@repo_infos = nil
+
+    # Register custom classes (Repo, Branch, CI) for a specific repository name.
+    #
+    # @param repo_name [String] Name of the repository (e.g. 'rdma-core')
+    # @param classes [Hash] Hash mapping default classes (e.g. Repo) to custom subclasses (e.g. RDMACoreRepo)
+    # @raise [GitMaintainError] If custom classes are already registered for this repository
+    def registerCustom(repo_name, classes)
+        raise GitMaintainError.new("Multiple class for repo #{repo_name}") if @@custom_classes[repo_name] != nil
+        classes[:name] = repo_name if classes[:name] == nil
+        @@custom_classes[repo_name] = classes
+    end
+    module_function :registerCustom
+
+    def getRepoInfos()
+        return @@repo_infos if @@repo_infos != nil
+
+        dir = File.realdirpath(".")
+        begin
+            repo_path = Common::run(dir, "git rev-parse  --show-toplevel 2> /dev/null")
+        rescue RunError
+            raise NotARepoError.new(dir)
+        end
+        return @@repo_infos = [repo_path, File.basename(repo_path)]
+    end
+    module_function :getRepoInfos
+
+    # Retrieve the registered custom subclass for a given default class and repository name.
+    # Returns the default_class if no custom class is registered.
+    #
+    # @param default_class [Class] Default class to resolve (e.g. Repo)
+    # @param repo_name [String] Repository name to search for
+    # @return [Class] The resolved class (either the custom subclass or the default_class)
+    def getExtendedClass(default_class, repo_name=nil)
+        begin
+            (_repo_path, repo_name) = getRepoInfos() if repo_name == nil
+            custom = @@custom_classes[repo_name]
+            if custom != nil && custom[default_class] != nil then
+                return custom[default_class]
+            else
+                return default_class
+            end
+        rescue NotARepoError
+            return default_class
+        end
+    end
+    module_function :getExtendedClass
+
+    # Retrieve all registered custom classes.
+    #
+    # @return [Hash] Registry of custom classes
+    def getCustomClasses()
+        return @@custom_classes
+    end
+    module_function :getCustomClasses
+
+    # Set whether verbose log is enabled.
+    #
+    # @param val [Boolean] True to enable verbose logs
+    def setVerbose(val)
+        self.verbose_log = val
+    end
+    module_function :setVerbose
+
+end
+
+require_relative 'ci'
+require_relative 'travis'
+require_relative 'azure'
+require_relative 'repo'
+require_relative 'branch'
+
+# Re-open the module to declare registry functions and load addons.
+module GitMaintain
+    # Pre-declaration
+    class BranchIterator < Common; end
+
+    # Action classes supported by git-maintain CLI.
+    ACTION_CLASS = [ Common, BranchIterator, Repo ]
+
+    # Load all custom classes from the default addons directory
+    loadAddons(File.expand_path('addons', __dir__))
+
+    # Load any eventual user custom directory if specified
+    if ENV["GIT_MAINTAIN_ADDON_DIR"].to_s != ""
+        loadAddons(ENV["GIT_MAINTAIN_ADDON_DIR"].to_s)
+    end
+end
+
+require_relative 'branch_iterator'

data/lib/git-maintain/error.rb

@@ -0,0 +1,81 @@
+module GitMaintain
+
+    # Base class for all GitMaintain exceptions
+    class GitMaintainError < RuntimeError
+    end
+
+    # Exception raised when cherry-pick is aborted by user
+    class CPAbort < GitMaintainError
+    end
+
+    # Exception raised when cherry-pick of a patch is skipped by user
+    class CPSkip < GitMaintainError
+        # Initialize a new SCPSkip error
+        # @param s [String] Message or patch info
+        def initialize(s="")
+            super("Skipping patch #{s}")
+        end
+    end
+
+    # Exception raised when a SHA is not found in the repository
+    class ShaNotFoundError < GitMaintainError
+        # Initialize a new ShaNotFoundError
+        # @param sha [String] The missing SHA
+        def initialize(sha)
+            super("SHA '#{sha}' was not found in the repository")
+        end
+    end
+
+    # Exception raised when a required argument is missing
+    class MissingArgumentError < GitMaintainError
+        # Initialize a new MissingArgumentError
+        # @param arg [String] The name of the missing argument
+        def initialize(arg)
+            super("Missing required argument: #{arg}")
+        end
+    end
+
+    # Exception raised when an argument is incorrect
+    class InvalidArgumentError < GitMaintainError
+        # Initialize a new InvalidArgumentError
+        # @param msg [String] Description of the invalid argument
+        def initialize(arg)
+            super("Invalid argument: #{arg}")
+        end
+    end
+
+    # Exception raised when a file is not found
+    class FileNotFoundError < GitMaintainError
+        # Initialize a new FileNotFoundError
+        # @param path [String] The path to the missing file
+        def initialize(path)
+            super("File not found: #{path}")
+        end
+    end
+
+    # Exception raised when a reference is not found in the repository
+    class NoRefError < GitMaintainError
+        def initialize(ref)
+            super("Reference '#{ref}' was not found")
+        end
+    end
+
+    # Exception raised when a cherry-pick fails
+    class CherryPickErrorException < GitMaintainError
+        def initialize(str, commit)
+            @commit = commit
+            super(str)
+        end
+        attr_reader :commit
+    end
+
+    # Exception raised when git-maintain is run outside of a git repository
+    class NotARepoError < GitMaintainError
+        # Initialize a new NotARepoError
+        # @param path [String] Path where repo was expected
+        def initialize(path)
+            super("'#{path}' is not a git repository")
+        end
+    end
+
+end