gitomator 0.1.1

data/lib/gitomator/service_provider/hosting_local.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+
+
+module Gitomator
+  module ServiceProvider
+    # A hosting provider that manages repos in a directory on the local
+    # file-system.
+    class HostingLocal
+
+
+      #-------------------------------------------------------------------------
+
+      #
+      # A small wrapper that takes a hash, and create an attr_accessor for
+      # each hash key.
+      # This is a temporary implementation, until we create proper model
+      # objects (e.g. HostedRepo, Team, PullRequest, etc.)
+      #
+      class ModelObject
+        def initialize(hash)
+          hash.each do |key, value|
+            setter = "#{key}="
+            self.class.send(:attr_accessor, key) if !respond_to?(setter)
+            send setter, value
+          end
+        end
+      end
+
+      #-------------------------------------------------------------------------
+
+
+      attr_reader :local_dir, :local_repos_dir
+
+      def initialize(git_service, local_dir, opts = {})
+        @git         = git_service
+
+        raise "Local directory doesn't exist, #{local_dir}" unless Dir.exist? local_dir
+        @local_dir   = local_dir
+
+        @local_repos_dir = File.join(@local_dir, opts[:repos_dir] || 'repos')
+        Dir.mkdir @local_repos_dir unless Dir.exist? @local_repos_dir
+      end
+
+      #---------------------------------------------------------------------
+
+      def name
+        :local
+      end
+
+
+      def repo_root(name)
+        File.join(local_repos_dir, name)
+      end
+
+      #---------------------------------------------------------------------
+
+      def create_repo(name, opts)
+        raise "Directory exists, #{repo_root(name)}" if Dir.exist? repo_root(name)
+        @git.init(repo_root(name), opts)
+        return ModelObject.new({
+          :name => name, :full_name => name, :url => "#{repo_root(name)}/.git"
+        })
+      end
+
+
+      def read_repo(name)
+        if Dir.exist? repo_root(name)
+          return ModelObject.new({
+            :name => name, :full_name => name, :url => "#{repo_root(name)}/.git"
+          })
+        else
+          return nil
+        end
+      end
+
+
+      def update_repo(name, opts={})
+        if opts[:name]
+          _rename_repo(name, opts[:name])
+        end
+        return read_repo(name)
+      end
+
+
+      def delete_repo(name)
+        if Dir.exist? repo_root(name)
+          FileUtils.rm_rf repo_root(name)
+        else
+          raise "No such repo, '#{name}'"
+        end
+        return nil
+      end
+
+
+      def _rename_repo(old_name, new_name)
+        raise "No such repo '#{old_name}'" unless Dir.exist? repo_root(old_name)
+        FileUtils.mv repo_root(old_name), repo_root(new_name)
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/task/base_repos_task.rb

@@ -0,0 +1,88 @@
+require 'gitomator/task'
+
+module Gitomator
+  module Task
+    class BaseReposTask < Gitomator::BaseTask
+
+      attr_reader :local_dir  # String or nil
+      attr_reader :repos      # Array<String>
+
+      #
+      # @param context [Gitomator::Context]
+      # @param auto_marker_config [Gitomator::Classroom::Config::AutoMarker] Parsed configuration object (TODO: Implement it as a subclass of Gitomator::Classroom::Assignment)
+      # @param local_dir [String] A local directory where the repos will be (or have been) cloned.
+      #
+      def initialize(context, repos, local_dir=nil)
+        super(context)
+        unless local_dir.nil?
+          raise "No such directory #{local_dir}" unless Dir.exists? local_dir
+        end
+        @local_dir = local_dir
+        @repos = repos
+        @blocks    = { :before => [], :after => [] }
+      end
+
+
+
+      def run()
+        @blocks[:before].each {|b| self.instance_exec(&b) }
+
+        repo2result, repo2error = {}, {}
+
+        repos.each_with_index do |repo, index|
+          logger.debug "#{repo} (#{index + 1} out of #{repos.length})"
+          begin
+            repo2result[repo] = process_repo(repo, index)
+          rescue => e
+            process_repo_error(repo, index, e)
+            repo2error[repo] = e
+          end
+        end
+
+        @blocks[:after].each {|b| self.instance_exec(repo2result, repo2error, &b) }
+      end
+
+
+
+      #
+      # You need to override this method!
+      #
+      # @param repo [String] The name of the repo
+      # @return Object (Optionally) return a result that can be used after processing all repos
+      #
+      def process_repo(repo, index)
+        raise "Unimplemented"
+      end
+
+      #
+      # Override this to provide custom error handling
+      #
+      def process_repo_error(repo, index, error)
+        logger.error "#{repo} : #{error}\n#{error.backtrace.join("\n\t")}"
+      end
+
+
+      #
+      # Inject a block that will run before processing any repos.
+      # The blocks takes no arguments, and doesn't (need to) return any specific value.
+      #
+      def before_processing_any_repos(&block)
+        @blocks[:before].push block
+      end
+
+      #
+      # Inject a block that will run after all repos have been processed.
+      #
+      # @yield [result2mark, repo2error]
+      # @yieldparam [Hash<String,Object>] repo2result
+      # @yieldparam [Hash<String,Error>]  repo2error
+      #
+      def after_processing_all_repos(&block)
+        @blocks[:after].push block
+      end
+
+
+
+    end
+  end
+end

data/lib/gitomator/task/clone_repos.rb

@@ -0,0 +1,61 @@
+require 'gitomator/task/base_repos_task'
+
+module Gitomator
+  module Task
+    class CloneRepos < Gitomator::Task::BaseReposTask
+
+
+      #
+      # @param context [Gitomator::Context]
+      # @param repos [Array<String>] The repos to clone
+      # @param local_dir [String] A local directory where the repos will be cloned.
+      # @param opts [Hash]
+      #
+      def initialize(context, repos, local_dir, opts={})
+        super(context, repos, local_dir)
+        @opts      = opts
+
+        before_processing_any_repos do
+          logger.debug "Clonning #{repos.length} repo(s) into #{local_dir} ..."
+        end
+
+        after_processing_all_repos do |repo2result, repo2error|
+          cloned  = repo2result.select {|_, result| result}.length
+          skipped = repo2result.reject {|_, result| result}.length
+          errored = repo2error.length
+          logger.info "Done (#{cloned} cloned, #{skipped} skipped, #{errored} errors)"
+        end
+      end
+
+
+      # override
+      def process_repo(source, index)
+        namespace = hosting.resolve_namespace(source)
+        repo_name = hosting.resolve_repo_name(source)
+        branch    = hosting.resolve_branch(source)
+
+        local_repo_root = File.join(@local_dir, repo_name)
+        if Dir.exist? local_repo_root
+          logger.info "Local clone exists, #{local_repo_root}"
+          return false
+        end
+
+        repo = hosting.read_repo(repo_name)
+        raise "No such remote repo, #{repo_name}" if repo.nil?
+
+        logger.info "git clone #{repo.url}"
+        git.clone(repo.url, local_repo_root)
+
+        unless branch.nil?
+          logger.debug("Switching to remote branch #{branch}")
+          git.checkout(local_repo_root, branch, {:is_new => true, :is_remote => true})
+        end
+
+        return true
+      end
+
+
+
+    end
+  end
+end

data/lib/gitomator/task/config/repos_config.rb

@@ -0,0 +1,117 @@
+
+module Gitomator
+  module Task
+    module Config
+
+
+      class ReposConfig
+
+        attr_reader :default_access_permission
+        attr_reader :repo_properties
+        attr_reader :source_repo
+
+        #
+        # @param config_obj [Hash] Configuration data (commonly loaded from a YAML file)
+        #
+        def initialize(config_obj)
+          raise "Missing required key, repos" unless config_obj.has_key? 'repos'
+          
+          @default_access_permission = (config_obj['default_access_permission'] || :read).to_sym
+          @source_repo = config_obj['source_repo']
+          @repo_properties = config_obj['repo_properties'] || {}
+
+          @repo2permissions = parse_repo2permissions(config_obj['repos'])
+        end
+
+
+        #
+        # @return [Enumerable<Strings>] The names of the repos.
+        #
+        def repos
+          @repo2permissions.keys
+        end
+
+        #
+        # @param repo [String] The name of a repository
+        # @return [Hash<String,Symbol>] Map name (user or team) to permission (:read/:write/:admin)
+        #
+        def permissions(repo)
+          @repo2permissions[repo]
+        end
+
+
+        # =================== Protected Helper Methods =========================
+
+        protected
+
+
+        #
+        # Helper function.
+        # @param repos_config [Array] Array of repo config items (various formats are supported)
+        #
+        def parse_repo2permissions(repos_config)
+          repo2permissions = {}
+
+          repos_config.each do |repo_config|
+            repo_name   = nil
+            permissions = {}
+
+            # 1. Parse it ...
+            if repo_config.is_a? String
+              repo_name = repo_config
+            elsif (repo_config.is_a? Hash) and (repo_config.length == 1)
+              repo_name   = repo_config.keys.first.to_s
+              permissions = parse_permissions(repo_config[repo_name])
+            else
+              raise Gitomator::Classroom::Exception::InvalidConfig.new(
+                  "Cannot parse #{repo_config} (expected String or a Hash with one entry)")
+            end
+
+            # 2. Check if there was an error ...
+            if repo2permissions.has_key? repo_config
+              raise Gitomator::Classroom::Exception::InvalidConfig.new("Duplicate property, #{repo_config}")
+            end
+
+            # 3. If no error, store the information
+            repo2permissions[repo_name] = permissions
+          end
+
+          return repo2permissions
+        end
+
+
+        #
+        # Parse the permissions configuration of a single repo into a hash that
+        # maps user/team names (Strings) to access-permissions (Symbols).
+        #
+        # Various configuration formats are supported:
+        #  * String - Single name, with default permission
+        #  * Hash - Maps names to permissions
+        #  * Array<String/Hash> - An array mixing both of the previous options.
+        #
+        # @param permissions_config [String/Hash/Array]
+        # @return [Hash<String,Symbol>]
+        #
+        def parse_permissions(permissions_config)
+          if permissions_config.is_a? String
+            return { permissions_config => default_access_permission }
+
+          elsif permissions_config.is_a? Hash
+            return permissions_config.map {|name,perm| [name, perm.to_sym] } .to_h
+
+          elsif permissions_config.is_a? Array
+            return permissions_config.map {|x| parse_permissions(x) } .reduce(:merge)
+
+          else
+            raise "Invalid permission configuration, #{permissions_config}"
+          end
+        end
+
+
+
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/task/config/team_config.rb

@@ -0,0 +1,57 @@
+module Gitomator
+  module Task
+    module Config
+
+      class TeamConfig
+
+
+        #=========================================================================
+        # Static factory methods
+
+        #
+        # @param config [Hash] - Configuration data (e.g. parsed from a YAML file)
+        # @return [Enumerable<Gitomator::Task::Config::TeamConfig>]
+        #
+        def self.from_hash(config)
+          return config.map {|name, members| new(name, members) }
+        end
+
+        #=========================================================================
+
+
+        attr_reader :name, :members  # Hash[String -> String], username to role
+
+        #
+        # @param name [String]
+        # @param members_config [Array] Each item is either a string (username) or Hash with one entry (username -> role)
+        #
+        def initialize(name, members_config)
+          @name    = name
+          @members = parse_members_config(members_config)
+        end
+
+
+        def parse_members_config(members_config)
+          result = {}
+
+          members_config.each do |entry|
+            if entry.is_a? String
+              result[entry] = 'member' # Default role is 'member'
+            elsif entry.is_a?(Hash) && entry.length == 1
+              result[entry.keys.first] = entry.values.first
+            else
+              raise "Invalid team-member config, #{entry}."
+            end
+          end
+
+          return result
+
+        end
+
+
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/task/enable_disable_ci.rb

@@ -0,0 +1,56 @@
+require 'gitomator/task/base_repos_task'
+
+module Gitomator
+  module Task
+
+    #
+    # Abstract parent class
+    #
+    class EnableDisableCI < Gitomator::Task::BaseReposTask
+
+      #
+      # @param context - Has a `ci` method that returns a Gitomator::Service::CI
+      # @param repos [Array<String>] - Names of the repos to enable/disable CI on.
+      # @param opts [Hash<Symbol,Object>] - Task options
+      # @option opts [Boolean] :sync - Indicate whether we should start by sync'ing the CI service.
+      #
+      def initialize(context, repos, opts={})
+        super(context, repos)
+
+        if opts[:sync]
+          before_processing_any_repos do
+            logger.info "Syncing CI service (this may take a little while) ..."
+            ci.sync()
+            while ci.syncing?
+              print "."
+              sleep 1
+            end
+            puts ""
+            logger.info "CI service synchronized"
+          end
+        end
+      end
+
+
+    end
+
+
+
+    class EnableCI < EnableDisableCI
+      def process_repo(repo_name, i)
+        logger.info "Enabling CI for #{repo_name} (#{i + 1} out of #{repos.length})"
+        ci.enable_ci repo_name
+      end
+    end
+
+
+    class DisableCI < EnableDisableCI
+      def process_repo(repo_name, i)
+        logger.info "Disabling CI for #{repo_name} (#{i + 1} out of #{repos.length})"
+        ci.disable_ci repo_name
+      end
+    end
+
+
+  end
+end

data/lib/gitomator/task/make_repos.rb

@@ -0,0 +1,86 @@
+require 'tmpdir'
+require 'gitomator/task/base_repos_task'
+require 'gitomator/task/clone_repos'
+
+module Gitomator
+  module Task
+    class MakeRepos < Gitomator::Task::BaseReposTask
+
+
+      attr_reader :source_repo
+      attr_reader :update_existing
+      attr_reader :repo_properties
+      attr_reader :source_repo_local_root
+
+      #
+      # @param context
+      # @param repos [Array<String>]
+      # @param opts [Hash<Symbol,Object>]
+      # @option opts [Hash<Symbol,Object>] :repo_properties - For example, :private, :description, :has_issues, etc.
+      # @option opts [String]  :source_repo - The name of a repo that will be the "starting point" of all the created repos.
+      # @option opts [Boolean] :update_existing - Update existing repos, by pushing latest commit(s) from the source_repo.
+      #
+      def initialize(context, repos, opts={})
+        super(context, repos)
+        @opts  = opts
+
+        @source_repo     = opts[:source_repo]
+        @update_existing = opts[:update_existing] || false
+        @repo_properties = opts[:repo_properties] || {}
+        @repo_properties = @repo_properties.map {|k,v| [k.to_sym,v] }.to_h
+
+        before_processing_any_repos do
+          logger.info "About to create/update #{repos.length} repo(s) ..."
+
+          if source_repo
+            tmp_dir = Dir.mktmpdir('Gitomator_')
+            Gitomator::Task::CloneRepos.new(context, [source_repo], tmp_dir).run()
+            repo_name = hosting.resolve_repo_name(source_repo)
+            @source_repo_local_root = File.join(tmp_dir, repo_name)
+          end
+        end
+      end
+
+
+
+      def process_repo(repo_name, index)
+        repo = hosting.read_repo(repo_name)
+
+        # If the repo doesn't exist, create it ...
+        if repo.nil?
+          logger.debug "Creating new repo #{repo_name} ..."
+          repo = hosting.create_repo(repo_name, repo_properties)
+          push_commits(repo, source_repo_local_root)
+
+        # If the repo exists, we might need to push changes, or update its properties
+        else
+          if update_existing
+            push_commits(repo, source_repo_local_root)
+          end
+          update_properties_if_needed(repo, repo_properties)
+        end
+      end
+
+
+      def push_commits(hosted_repo, local_repo)
+        if local_repo
+          logger.debug "Pushing commits from #{local_repo} to #{hosted_repo.name} "
+          git.set_remote(local_repo, hosted_repo.name, hosted_repo.url, {create: true})
+          git.command(local_repo, "push #{hosted_repo.name} HEAD:master")
+        end
+      end
+
+
+      def update_properties_if_needed(repo, props)
+        p = repo.properties
+        diff = props.select {|k,v| p.has_key?(k) && p[k] != v}
+        unless(diff.empty?)
+          logger.debug "Updating #{repo.name} properties #{diff}"
+          hosting.update_repo(repo.name, diff)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/task/setup_team.rb

@@ -0,0 +1,63 @@
+require 'gitomator/task'
+require 'set'
+
+module Gitomator
+  module Task
+
+    class SetupTeam < Gitomator::BaseTask
+
+      #
+      # @param context
+      # @param team_name [String]
+      # @param member2role [Hash<String,String>] Map usernames to roles.
+      # @param opts [Hash]
+      #
+      def initialize(context, team_name, member2role, opts={})
+        super(context)
+        @team_name   = team_name
+        @member2role = member2role
+        @opts = opts
+      end
+
+
+
+      def run
+        create_team_if_missing()
+        @member2role.each do |username, role|
+          begin
+            create_or_update_membership(username, role)
+          rescue => e
+            logger.error("Cannot create/update #{username}'s membership in " +
+                         "#{@team_name} - #{e}.\n#{e.backtrace.join("\n\t")}")
+          end
+        end
+      end
+
+
+      def create_team_if_missing
+        if hosting.read_team(@team_name).nil?
+          logger.info("Creating team: #{@team_name}")
+          hosting.create_team(@team_name)
+        else
+          logger.debug("Team #{@team_name} exists.")
+        end
+      end
+
+
+      def create_or_update_membership(username, role)
+        current_role = hosting.read_team_membership(@team_name, username)
+        if current_role.nil?
+          logger.info("Adding #{username} to team #{@team_name} (role: #{role}).")
+          hosting.create_team_membership(@team_name, username, role)
+        elsif current_role != role
+          logger.info("Updating #{username}'s role from #{current_role} to #{role} (team: #{@team_name})")
+          hosting.update_team_membership(@team_name, username, role)
+        else
+          logger.debug("Skipping #{username}, already a #{role} of #{@team_name}.")
+        end
+      end
+
+
+    end
+  end
+end

data/lib/gitomator/task/update_repo_access_permissions.rb

@@ -0,0 +1,42 @@
+require 'gitomator/task'
+require 'set'
+
+module Gitomator
+  module Task
+
+    class UpdateRepoAccessPermissions < Gitomator::BaseTask
+
+      #
+      # @param context
+      # @param repo_name [String]
+      # @param user2perm [Hash<String,Symbol>] Map usernames to permission type (:read/:write).
+      # @param team2perm [Hash<String,Symbol>] Map team-names to permission type (:read/:write).
+      # @param opts [Hash]
+      #
+      def initialize(context, repo_name, user2perm, team2perm, opts={})
+        super(context)
+        @repo_name = repo_name
+        @user2perm = user2perm || {}
+        @team2perm = team2perm || {}
+        @opts = opts
+      end
+
+
+
+      def run
+        @user2perm.each do |username, permission|
+          logger.info("Granting user #{username} #{permission} permission to #{@repo_name}")
+          hosting.set_user_permission(username, @repo_name, permission)
+        end
+
+        @team2perm.each do |team_name, permission|
+          logger.info("Granting team #{team_name} #{permission} permission to #{@repo_name}")
+          hosting.set_team_permission(team_name, @repo_name, permission)
+        end
+      end
+
+
+
+    end
+  end
+end