Merge branch 'master' into issue-discussions-refactor

# Conflicts:
#	app/models/issue.rb

34 files changed, 363 insertions, 145 deletions

diff --git a/lib/after_commit_queue.rb b/lib/after_commit_queue.rb
index b67575a3ac2..4750a2c373a 100644
--- a/lib/after_commit_queue.rb
+++ b/lib/after_commit_queue.rb
@@ -7,7 +7,7 @@ module AfterCommitQueue
   end
 
   def run_after_commit(method = nil, &block)
-    _after_commit_queue << proc { self.send(method) } if method
+    _after_commit_queue << proc { self.send(method) } if method # rubocop:disable GitlabSecurity/PublicSend
     _after_commit_queue << block if block
     true
   end
diff --git a/lib/api/groups.rb b/lib/api/groups.rb
index 49c3b2278c7..e56427304a6 100644
--- a/lib/api/groups.rb
+++ b/lib/api/groups.rb
@@ -2,7 +2,7 @@ module API
   class Groups < Grape::API
     include PaginationParams
 
-    before { authenticate! }
+    before { authenticate_non_get! }
 
     helpers do
       params :optional_params_ce do
@@ -47,16 +47,8 @@ module API
         use :pagination
       end
       get do
-        groups = if params[:owned]
-                   current_user.owned_groups
-                 elsif current_user.admin
-                   Group.all
-                 elsif params[:all_available]
-                   GroupsFinder.new(current_user).execute
-                 else
-                   current_user.groups
-                 end
-
+        find_params = { all_available: params[:all_available], owned: params[:owned] }
+        groups = GroupsFinder.new(current_user, find_params).execute
         groups = groups.search(params[:search]) if params[:search].present?
         groups = groups.where.not(id: params[:skip_groups]) if params[:skip_groups].present?
         groups = groups.reorder(params[:order_by] => params[:sort])
diff --git a/lib/api/runner.rb b/lib/api/runner.rb
index 88fc62d33df..1a7ded31c91 100644
--- a/lib/api/runner.rb
+++ b/lib/api/runner.rb
@@ -78,7 +78,7 @@ module API
         no_content! unless current_runner.active?
         update_runner_info
 
-        if current_runner.is_runner_queue_value_latest?(params[:last_update])
+        if current_runner.runner_queue_value_latest?(params[:last_update])
           header 'X-GitLab-Last-Update', params[:last_update]
           Gitlab::Metrics.add_event(:build_not_found_cached)
           return no_content!
diff --git a/lib/github/import.rb b/lib/github/import.rb
index 4cc01593ef4..7b848081e85 100644
--- a/lib/github/import.rb
+++ b/lib/github/import.rb
@@ -107,7 +107,7 @@ module Github
       # this means that repo has wiki enabled, but have no pages. So,
       # we can skip the import.
       if e.message !~ /repository not exported/
-        errors(:wiki, wiki_url, e.message)
+        error(:wiki, wiki_url, e.message)
       end
     end
 
diff --git a/lib/gitlab/bare_repository_importer.rb b/lib/gitlab/bare_repository_importer.rb
new file mode 100644
index 00000000000..9323bfc7fb2
--- /dev/null
+++ b/lib/gitlab/bare_repository_importer.rb
@@ -0,0 +1,96 @@
+module Gitlab
+  class BareRepositoryImporter
+    NoAdminError = Class.new(StandardError)
+
+    def self.execute
+      Gitlab.config.repositories.storages.each do |storage_name, repository_storage|
+        git_base_path = repository_storage['path']
+        repos_to_import = Dir.glob(git_base_path + '/**/*.git')
+
+        repos_to_import.each do |repo_path|
+          if repo_path.end_with?('.wiki.git')
+            log " * Skipping wiki repo"
+            next
+          end
+
+          log "Processing #{repo_path}".color(:yellow)
+
+          repo_relative_path = repo_path[repository_storage['path'].length..-1]
+                                 .sub(/^\//, '') # Remove leading `/`
+                                 .sub(/\.git$/, '') # Remove `.git` at the end
+          new(storage_name, repo_relative_path).create_project_if_needed
+        end
+      end
+    end
+
+    attr_reader :storage_name, :full_path, :group_path, :project_path, :user
+    delegate :log, to: :class
+
+    def initialize(storage_name, repo_path)
+      @storage_name = storage_name
+      @full_path = repo_path
+
+      unless @user = User.admins.order_id_asc.first
+        raise NoAdminError.new('No admin user found to import repositories')
+      end
+
+      @group_path, @project_path = File.split(repo_path)
+      @group_path = nil if @group_path == '.'
+    end
+
+    def create_project_if_needed
+      if project = Project.find_by_full_path(full_path)
+        log " * #{project.name} (#{full_path}) exists"
+        return project
+      end
+
+      create_project
+    end
+
+    private
+
+    def create_project
+      group = find_or_create_group
+
+      project_params = {
+        name: project_path,
+        path: project_path,
+        repository_storage: storage_name,
+        namespace_id: group&.id
+      }
+
+      project = Projects::CreateService.new(user, project_params).execute
+
+      if project.persisted?
+        log " * Created #{project.name} (#{full_path})".color(:green)
+        ProjectCacheWorker.perform_async(project.id)
+      else
+        log " * Failed trying to create #{project.name} (#{full_path})".color(:red)
+        log "   Errors: #{project.errors.messages}".color(:red)
+      end
+
+      project
+    end
+
+    def find_or_create_group
+      return nil unless group_path
+
+      if namespace = Namespace.find_by_full_path(group_path)
+        log " * Namespace #{group_path} exists.".color(:green)
+        return namespace
+      end
+
+      log " * Creating Group: #{group_path}"
+      Groups::NestedCreateService.new(user, group_path: group_path).execute
+    end
+
+    # This is called from within a rake task only used by Admins, so allow writing
+    # to STDOUT
+    #
+    # rubocop:disable Rails/Output
+    def self.log(message)
+      puts message
+    end
+    # rubocop:enable Rails/Output
+  end
+end
diff --git a/lib/gitlab/checks/force_push.rb b/lib/gitlab/checks/force_push.rb
index 714464fd5e7..dc5d285ea65 100644
--- a/lib/gitlab/checks/force_push.rb
+++ b/lib/gitlab/checks/force_push.rb
@@ -12,7 +12,7 @@ module Gitlab
             !project
               .repository
               .gitaly_commit_client
-              .is_ancestor(oldrev, newrev)
+              .ancestor?(oldrev, newrev)
           else
             Gitlab::Git::RevList.new(
               path_to_repo: project.repository.path_to_repo,
diff --git a/lib/gitlab/data_builder/push.rb b/lib/gitlab/data_builder/push.rb
index 5c5f507d44d..4ab5b3455a5 100644
--- a/lib/gitlab/data_builder/push.rb
+++ b/lib/gitlab/data_builder/push.rb
@@ -3,6 +3,35 @@ module Gitlab
     module Push
       extend self
 
+      SAMPLE_DATA =
+        {
+          object_kind: "push",
+          event_name: "push",
+          before: "95790bf891e76fee5e1747ab589903a6a1f80f22",
+          after: "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
+          ref: "refs/heads/master",
+          checkout_sha: "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
+          message: "Hello World",
+          user_id: 4,
+          user_name: "John Smith",
+          user_email: "john@example.com",
+          user_avatar: "https://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=8://s.gravatar.com/avatar/d4c74594d841139328695756648b6bd6?s=80",
+          project_id: 15,
+          commits: [
+            {
+              id: "c5feabde2d8cd023215af4d2ceeb7a64839fc428",
+              message: "Add simple search to projects in public area",
+              timestamp: "2013-05-13T18:18:08+00:00",
+              url: "https://test.example.com/gitlab/gitlabhq/commit/c5feabde2d8cd023215af4d2ceeb7a64839fc428",
+              author: {
+                name: "Test User",
+                email: "test@example.com"
+              }
+            }
+          ],
+          total_commits_count: 1
+        }.freeze
+
       # Produce a hash of post-receive data
       #
       # data = {
@@ -74,6 +103,10 @@ module Gitlab
         build(project, user, commits.last&.id, commits.first&.id, ref, commits)
       end
 
+      def sample_data
+        SAMPLE_DATA
+      end
+
       private
 
       def checkout_sha(repository, newrev, ref)
diff --git a/lib/gitlab/data_builder/repository.rb b/lib/gitlab/data_builder/repository.rb
index b42dc052949..c9c13ec6487 100644
--- a/lib/gitlab/data_builder/repository.rb
+++ b/lib/gitlab/data_builder/repository.rb
@@ -3,6 +3,23 @@ module Gitlab
     module Repository
       extend self
 
+      SAMPLE_DATA = {
+        event_name: 'repository_update',
+        user_id: 10,
+        user_name: 'john.doe',
+        user_email: 'test@example.com',
+        user_avatar: 'http://example.com/avatar/user.png',
+        project_id: 40,
+        changes: [
+          {
+            before: "8205ea8d81ce0c6b90fbe8280d118cc9fdad6130",
+            after: "4045ea7a3df38697b3730a20fb73c8bed8a3e69e",
+            ref: "refs/heads/master"
+          }
+        ],
+        "refs": ["refs/heads/master"]
+      }.freeze
+
       # Produce a hash of post-receive data
       def update(project, user, changes, refs)
         {
@@ -30,6 +47,10 @@ module Gitlab
           ref: ref
         }
       end
+
+      def sample_data
+        SAMPLE_DATA
+      end
     end
   end
 end
diff --git a/lib/gitlab/database/migration_helpers.rb b/lib/gitlab/database/migration_helpers.rb
index b83e633c7ed..5e2c6cc5cad 100644
--- a/lib/gitlab/database/migration_helpers.rb
+++ b/lib/gitlab/database/migration_helpers.rb
@@ -611,6 +611,20 @@ module Gitlab
         remove_foreign_key(*args)
       rescue ArgumentError
       end
+
+      def sidekiq_queue_migrate(queue_from, to:)
+        while sidekiq_queue_length(queue_from) > 0
+          Sidekiq.redis do |conn|
+            conn.rpoplpush "queue:#{queue_from}", "queue:#{to}"
+          end
+        end
+      end
+
+      def sidekiq_queue_length(queue_name)
+        Sidekiq.redis do |conn|
+          conn.llen("queue:#{queue_name}")
+        end
+      end
     end
   end
 end
diff --git a/lib/gitlab/diff/file.rb b/lib/gitlab/diff/file.rb
index 6d7de52cb80..1dabd4ebdd0 100644
--- a/lib/gitlab/diff/file.rb
+++ b/lib/gitlab/diff/file.rb
@@ -186,7 +186,10 @@ module Gitlab
       end
 
       def content_changed?
-        old_blob && new_blob && old_blob.id != new_blob.id
+        return blobs_changed? if diff_refs
+        return false if new_file? || deleted_file? || renamed_file?
+
+        text? && diff_lines.any?
       end
 
       def different_type?
@@ -225,6 +228,10 @@ module Gitlab
 
       private
 
+      def blobs_changed?
+        old_blob && new_blob && old_blob.id != new_blob.id
+      end
+
       def simple_viewer_class
         return DiffViewer::NotDiffable unless diffable?
 
@@ -250,6 +257,8 @@ module Gitlab
           DiffViewer::Renamed
         elsif mode_changed?
           DiffViewer::ModeChanged
+        else
+          DiffViewer::NoPreview
         end
       end
 
diff --git a/lib/gitlab/file_finder.rb b/lib/gitlab/file_finder.rb
index 093d9ed8092..10ffc345bd5 100644
--- a/lib/gitlab/file_finder.rb
+++ b/lib/gitlab/file_finder.rb
@@ -6,27 +6,48 @@ module Gitlab
 
     attr_reader :project, :ref
 
+    delegate :repository, to: :project
+
     def initialize(project, ref)
       @project = project
       @ref = ref
     end
 
     def find(query)
-      blobs = project.repository.search_files_by_content(query, ref).first(BATCH_SIZE)
-      found_file_names = Set.new
+      by_content = find_by_content(query)
 
-      results = blobs.map do |blob|
-        blob = Gitlab::ProjectSearchResults.parse_search_result(blob)
-        found_file_names << blob.filename
+      already_found = Set.new(by_content.map(&:filename))
+      by_filename = find_by_filename(query, except: already_found)
 
-        [blob.filename, blob]
-      end
+      (by_content + by_filename)
+        .sort_by(&:filename)
+        .map { |blob| [blob.filename, blob] }
+    end
 
-      project.repository.search_files_by_name(query, ref).first(BATCH_SIZE).each do |filename|
-        results << [filename, OpenStruct.new(ref: ref)] unless found_file_names.include?(filename)
-      end
+    private
 
-      results.sort_by(&:first)
+    def find_by_content(query)
+      results = repository.search_files_by_content(query, ref).first(BATCH_SIZE)
+      results.map { |result| Gitlab::ProjectSearchResults.parse_search_result(result) }
+    end
+
+    def find_by_filename(query, except: [])
+      filenames = repository.search_files_by_name(query, ref).first(BATCH_SIZE)
+      filenames.delete_if { |filename| except.include?(filename) } unless except.empty?
+
+      blob_refs = filenames.map { |filename| [ref, filename] }
+      blobs = Gitlab::Git::Blob.batch(repository, blob_refs, blob_size_limit: 1024)
+
+      blobs.map do |blob|
+        Gitlab::SearchResults::FoundBlob.new(
+          id: blob.id,
+          filename: blob.path,
+          basename: File.basename(blob.path),
+          ref: ref,
+          startline: 1,
+          data: blob.data
+        )
+      end
     end
   end
 end
diff --git a/lib/gitlab/git/commit.rb b/lib/gitlab/git/commit.rb
index a499bbc6266..5ee6669050c 100644
--- a/lib/gitlab/git/commit.rb
+++ b/lib/gitlab/git/commit.rb
@@ -271,7 +271,13 @@ module Gitlab
       #
       # Gitaly migration: https://gitlab.com/gitlab-org/gitaly/issues/324
       def to_diff
-        rugged_diff_from_parent.patch
+        Gitlab::GitalyClient.migrate(:commit_patch) do |is_enabled|
+          if is_enabled
+            @repository.gitaly_commit_client.patch(id)
+          else
+            rugged_diff_from_parent.patch
+          end
+        end
       end
 
       # Returns a diff object for the changes from this commit's first parent.
diff --git a/lib/gitlab/git/committer.rb b/lib/gitlab/git/committer.rb
new file mode 100644
index 00000000000..1f4bcf7a3a0
--- /dev/null
+++ b/lib/gitlab/git/committer.rb
@@ -0,0 +1,21 @@
+module Gitlab
+  module Git
+    class Committer
+      attr_reader :name, :email, :gl_id
+
+      def self.from_user(user)
+        new(user.name, user.email, Gitlab::GlId.gl_id(user))
+      end
+
+      def initialize(name, email, gl_id)
+        @name = name
+        @email = email
+        @gl_id = gl_id
+      end
+
+      def ==(other)
+        [name, email, gl_id] == [other.name, other.email, other.gl_id]
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/git/hook.rb b/lib/gitlab/git/hook.rb
index 8f0c377ef4f..cc35d77c6e4 100644
--- a/lib/gitlab/git/hook.rb
+++ b/lib/gitlab/git/hook.rb
@@ -1,20 +1,23 @@
-# Gitaly note: JV: looks like this is only used by GitHooksService in
+# Gitaly note: JV: looks like this is only used by Gitlab::Git::HooksService in
 # app/services. We shouldn't bother migrating this until we know how
-# GitHooksService will be migrated.
+# Gitlab::Git::HooksService will be migrated.
 
 module Gitlab
   module Git
     class Hook
       GL_PROTOCOL = 'web'.freeze
-      attr_reader :name, :repo_path, :path
+      attr_reader :name, :path, :repository
 
-      def initialize(name, project)
+      def initialize(name, repository)
         @name = name
-        @project = project
-        @repo_path = project.repository.path
+        @repository = repository
         @path = File.join(repo_path.strip, 'hooks', name)
       end
 
+      def repo_path
+        repository.path
+      end
+
       def exists?
         File.exist?(path)
       end
@@ -44,7 +47,7 @@ module Gitlab
           'GL_ID' => gl_id,
           'PWD' => repo_path,
           'GL_PROTOCOL' => GL_PROTOCOL,
-          'GL_REPOSITORY' => Gitlab::GlRepository.gl_repository(@project, false)
+          'GL_REPOSITORY' => repository.gl_repository
         }
 
         options = {
diff --git a/lib/gitlab/git/hooks_service.rb b/lib/gitlab/git/hooks_service.rb
new file mode 100644
index 00000000000..ea8a87a1290
--- /dev/null
+++ b/lib/gitlab/git/hooks_service.rb
@@ -0,0 +1,36 @@
+module Gitlab
+  module Git
+    class HooksService
+      PreReceiveError = Class.new(StandardError)
+
+      attr_accessor :oldrev, :newrev, :ref
+
+      def execute(committer, repository, oldrev, newrev, ref)
+        @repository = repository
+        @gl_id      = committer.gl_id
+        @oldrev     = oldrev
+        @newrev     = newrev
+        @ref        = ref
+
+        %w(pre-receive update).each do |hook_name|
+          status, message = run_hook(hook_name)
+
+          unless status
+            raise PreReceiveError, message
+          end
+        end
+
+        yield(self).tap do
+          run_hook('post-receive')
+        end
+      end
+
+      private
+
+      def run_hook(name)
+        hook = Gitlab::Git::Hook.new(name, @repository)
+        hook.trigger(@gl_id, oldrev, newrev, ref)
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/git/repository.rb b/lib/gitlab/git/repository.rb
index eb3731ba35a..03e2bec84dd 100644
--- a/lib/gitlab/git/repository.rb
+++ b/lib/gitlab/git/repository.rb
@@ -49,13 +49,14 @@ module Gitlab
       # Rugged repo object
       attr_reader :rugged
 
-      attr_reader :storage
+      attr_reader :storage, :gl_repository, :relative_path
 
       # 'path' must be the path to a _bare_ git repository, e.g.
       # /path/to/my-repo.git
-      def initialize(storage, relative_path)
+      def initialize(storage, relative_path, gl_repository)
         @storage = storage
         @relative_path = relative_path
+        @gl_repository = gl_repository
 
         storage_path = Gitlab.config.repositories.storages[@storage]['path']
         @path = File.join(storage_path, @relative_path)
@@ -153,7 +154,7 @@ module Gitlab
           if is_enabled
             gitaly_ref_client.count_branch_names
           else
-            rugged.branches.count do |ref|
+            rugged.branches.each(:local).count do |ref|
               begin
                 ref.name && ref.target # ensures the branch is valid
 
@@ -201,6 +202,19 @@ module Gitlab
         end
       end
 
+      # Returns true if the given ref name exists
+      #
+      # Ref names must start with `refs/`.
+      def ref_exists?(ref_name)
+        gitaly_migrate(:ref_exists) do |is_enabled|
+          if is_enabled
+            gitaly_ref_exists?(ref_name)
+          else
+            rugged_ref_exists?(ref_name)
+          end
+        end
+      end
+
       # Returns true if the given tag exists
       #
       # name - The name of the tag as a String.
@@ -425,8 +439,8 @@ module Gitlab
       end
 
       # Returns true is +from+ is direct ancestor to +to+, otherwise false
-      def is_ancestor?(from, to)
-        gitaly_commit_client.is_ancestor(from, to)
+      def ancestor?(from, to)
+        gitaly_commit_client.ancestor?(from, to)
       end
 
       # Return an array of Diff objects that represent the diff
@@ -992,6 +1006,16 @@ module Gitlab
       # Returns true if the given ref name exists
       #
       # Ref names must start with `refs/`.
+      def rugged_ref_exists?(ref_name)
+        raise ArgumentError, 'invalid refname' unless ref_name.start_with?('refs/')
+        rugged.references.exist?(ref_name)
+      rescue Rugged::ReferenceError
+        false
+      end
+
+      # Returns true if the given ref name exists
+      #
+      # Ref names must start with `refs/`.
       def gitaly_ref_exists?(ref_name)
         gitaly_ref_client.ref_exists?(ref_name)
       end
diff --git a/lib/gitlab/gitaly_client/commit_service.rb b/lib/gitlab/gitaly_client/commit_service.rb
index 2d58fb0186e..21a32a7e0db 100644
--- a/lib/gitlab/gitaly_client/commit_service.rb
+++ b/lib/gitlab/gitaly_client/commit_service.rb
@@ -22,7 +22,7 @@ module Gitlab
         end
       end
 
-      def is_ancestor(ancestor_id, child_id)
+      def ancestor?(ancestor_id, child_id)
         request = Gitaly::CommitIsAncestorRequest.new(
           repository: @gitaly_repo,
           ancestor_id: ancestor_id,
@@ -175,8 +175,8 @@ module Gitlab
       def raw_blame(revision, path)
         request = Gitaly::RawBlameRequest.new(
           repository: @gitaly_repo,
-          revision: revision,
-          path: path
+          revision: GitalyClient.encode(revision),
+          path: GitalyClient.encode(path)
         )
 
         response = GitalyClient.call(@repository.storage, :commit_service, :raw_blame, request)
@@ -194,6 +194,16 @@ module Gitlab
         response.commit
       end
 
+      def patch(revision)
+        request = Gitaly::CommitPatchRequest.new(
+          repository: @gitaly_repo,
+          revision: GitalyClient.encode(revision)
+        )
+        response = GitalyClient.call(@repository.storage, :diff_service, :commit_patch, request)
+
+        response.sum(&:data)
+      end
+
       private
 
       def commit_diff_request_params(commit, options = {})
diff --git a/lib/gitlab/gitaly_client/ref_service.rb b/lib/gitlab/gitaly_client/ref_service.rb
index cdcfed36740..8c0008c6971 100644
--- a/lib/gitlab/gitaly_client/ref_service.rb
+++ b/lib/gitlab/gitaly_client/ref_service.rb
@@ -71,7 +71,7 @@ module Gitlab
       end
 
       def ref_exists?(ref_name)
-        request = Gitaly::RefExistsRequest.new(repository: @gitaly_repo, ref: ref_name)
+        request = Gitaly::RefExistsRequest.new(repository: @gitaly_repo, ref: GitalyClient.encode(ref_name))
         response = GitalyClient.call(@storage, :ref_service, :ref_exists, request)
         response.value
       rescue GRPC::InvalidArgument => e
diff --git a/lib/gitlab/health_checks/db_check.rb b/lib/gitlab/health_checks/db_check.rb
index fd94984f8a2..e27e16ddaf6 100644
--- a/lib/gitlab/health_checks/db_check.rb
+++ b/lib/gitlab/health_checks/db_check.rb
@@ -10,7 +10,7 @@ module Gitlab
           'db_ping'
         end
 
-        def is_successful?(result)
+        def successful?(result)
           result == '1'
         end
 
diff --git a/lib/gitlab/health_checks/redis/cache_check.rb b/lib/gitlab/health_checks/redis/cache_check.rb
index a28658d42d4..0eb9b77634a 100644
--- a/lib/gitlab/health_checks/redis/cache_check.rb
+++ b/lib/gitlab/health_checks/redis/cache_check.rb
@@ -15,7 +15,7 @@ module Gitlab
             'redis_cache_ping'
           end
 
-          def is_successful?(result)
+          def successful?(result)
             result == 'PONG'
           end
 
diff --git a/lib/gitlab/health_checks/redis/queues_check.rb b/lib/gitlab/health_checks/redis/queues_check.rb
index f97d50d3947..f322fe831b8 100644
--- a/lib/gitlab/health_checks/redis/queues_check.rb
+++ b/lib/gitlab/health_checks/redis/queues_check.rb
@@ -15,7 +15,7 @@ module Gitlab
             'redis_queues_ping'
           end
 
-          def is_successful?(result)
+          def successful?(result)
             result == 'PONG'
           end
 
diff --git a/lib/gitlab/health_checks/redis/redis_check.rb b/lib/gitlab/health_checks/redis/redis_check.rb
index fe4e3c4a3ab..8ceb0a0aa46 100644
--- a/lib/gitlab/health_checks/redis/redis_check.rb
+++ b/lib/gitlab/health_checks/redis/redis_check.rb
@@ -11,7 +11,7 @@ module Gitlab
             'redis_ping'
           end
 
-          def is_successful?(result)
+          def successful?(result)
             result == 'PONG'
           end
 
diff --git a/lib/gitlab/health_checks/redis/shared_state_check.rb b/lib/gitlab/health_checks/redis/shared_state_check.rb
index e3244392902..07e6f707998 100644
--- a/lib/gitlab/health_checks/redis/shared_state_check.rb
+++ b/lib/gitlab/health_checks/redis/shared_state_check.rb
@@ -15,7 +15,7 @@ module Gitlab
             'redis_shared_state_ping'
           end
 
-          def is_successful?(result)
+          def successful?(result)
             result == 'PONG'
           end
 
diff --git a/lib/gitlab/health_checks/simple_abstract_check.rb b/lib/gitlab/health_checks/simple_abstract_check.rb
index f5026171ba4..96945ce5b20 100644
--- a/lib/gitlab/health_checks/simple_abstract_check.rb
+++ b/lib/gitlab/health_checks/simple_abstract_check.rb
@@ -5,7 +5,7 @@ module Gitlab
 
       def readiness
         check_result = check
-        if is_successful?(check_result)
+        if successful?(check_result)
           HealthChecks::Result.new(true)
         elsif check_result.is_a?(Timeout::Error)
           HealthChecks::Result.new(false, "#{human_name} check timed out")
@@ -16,10 +16,10 @@ module Gitlab
 
       def metrics
         result, elapsed = with_timing(&method(:check))
-        Rails.logger.error("#{human_name} check returned unexpected result #{result}") unless is_successful?(result)
+        Rails.logger.error("#{human_name} check returned unexpected result #{result}") unless successful?(result)
         [
           metric("#{metric_prefix}_timeout", result.is_a?(Timeout::Error) ? 1 : 0),
-          metric("#{metric_prefix}_success", is_successful?(result) ? 1 : 0),
+          metric("#{metric_prefix}_success", successful?(result) ? 1 : 0),
           metric("#{metric_prefix}_latency_seconds", elapsed)
         ]
       end
@@ -30,7 +30,7 @@ module Gitlab
         raise NotImplementedError
       end
 
-      def is_successful?(result)
+      def successful?(result)
         raise NotImplementedError
       end
 
diff --git a/lib/gitlab/import_export/import_export.yml b/lib/gitlab/import_export/import_export.yml
index e5d4bb686e7..78795dd3d92 100644
--- a/lib/gitlab/import_export/import_export.yml
+++ b/lib/gitlab/import_export/import_export.yml
@@ -138,3 +138,7 @@ methods:
     - :target_branch_sha
   project:
     - :description_html
+  events:
+    - :action
+  push_event_payload:
+    - :action
\ No newline at end of file
diff --git a/lib/gitlab/ldap/adapter.rb b/lib/gitlab/ldap/adapter.rb
index 8867a91c244..cd7e4ca7b7e 100644
--- a/lib/gitlab/ldap/adapter.rb
+++ b/lib/gitlab/ldap/adapter.rb
@@ -73,7 +73,7 @@ module Gitlab
       private
 
       def user_options(field, value, limit)
-        options = { attributes: user_attributes }
+        options = { attributes: Gitlab::LDAP::Person.ldap_attributes(config).compact.uniq }
         options[:size] = limit if limit
 
         if field.to_sym == :dn
@@ -99,10 +99,6 @@ module Gitlab
           filter
         end
       end
-
-      def user_attributes
-        %W(#{config.uid} cn dn) + config.attributes['username'] + config.attributes['email']
-      end
     end
   end
 end
diff --git a/lib/gitlab/ldap/person.rb b/lib/gitlab/ldap/person.rb
index e138b466a34..4d6f8ac79de 100644
--- a/lib/gitlab/ldap/person.rb
+++ b/lib/gitlab/ldap/person.rb
@@ -21,6 +21,15 @@ module Gitlab
         adapter.dn_matches_filter?(dn, AD_USER_DISABLED)
       end
 
+      def self.ldap_attributes(config)
+        [
+          'dn', # Used in `dn`
+          config.uid, # Used in `uid`
+          *config.attributes['name'], # Used in `name`
+          *config.attributes['email'] # Used in `email`
+        ]
+      end
+
       def initialize(entry, provider)
         Rails.logger.debug { "Instantiating #{self.class.name} with LDIF:\n#{entry.to_ldif}" }
         @entry = entry
diff --git a/lib/gitlab/prometheus/queries/matched_metrics_query.rb b/lib/gitlab/prometheus/queries/matched_metrics_query.rb
index d4894c87f8d..4c3edccc71a 100644
--- a/lib/gitlab/prometheus/queries/matched_metrics_query.rb
+++ b/lib/gitlab/prometheus/queries/matched_metrics_query.rb
@@ -42,13 +42,13 @@ module Gitlab
 
           lookup = series.each_slice(MAX_QUERY_ITEMS).flat_map do |batched_series|
             client_series(*batched_series, start: timeframe_start, stop: timeframe_end)
-              .select(&method(:has_matching_label))
+              .select(&method(:has_matching_label?))
               .map { |series_info| [series_info['__name__'], true] }
           end
           lookup.to_h
         end
 
-        def has_matching_label(series_info)
+        def has_matching_label?(series_info)
           series_info.key?('environment')
         end
 
diff --git a/lib/system_check/app/git_config_check.rb b/lib/system_check/app/git_config_check.rb
index 198867f7ac6..d08a81639e3 100644
--- a/lib/system_check/app/git_config_check.rb
+++ b/lib/system_check/app/git_config_check.rb
@@ -20,7 +20,7 @@ module SystemCheck
       # Returns true if all subcommands were successful (according to their exit code)
       # Returns false if any or all subcommands failed.
       def repair!
-        return false unless is_gitlab_user?
+        return false unless gitlab_user?
 
         command_success = OPTIONS.map do |name, value|
           system(*%W(#{Gitlab.config.git.bin_path} config --global #{name} #{value}))
diff --git a/lib/system_check/base_check.rb b/lib/system_check/base_check.rb
index 5dcb3f0886b..7f9e2ffffc2 100644
--- a/lib/system_check/base_check.rb
+++ b/lib/system_check/base_check.rb
@@ -73,7 +73,7 @@ module SystemCheck
       self.class.instance_methods(false).include?(:skip?)
     end
 
-    def is_multi_check?
+    def multi_check?
       self.class.instance_methods(false).include?(:multi_check)
     end
 
diff --git a/lib/system_check/simple_executor.rb b/lib/system_check/simple_executor.rb
index e5986612908..6604b1078cf 100644
--- a/lib/system_check/simple_executor.rb
+++ b/lib/system_check/simple_executor.rb
@@ -53,7 +53,7 @@ module SystemCheck
       end
 
       # When implements a multi check, we don't control the output
-      if check.is_multi_check?
+      if check.multi_check?
         check.multi_check
         return
       end
diff --git a/lib/tasks/gitlab/import.rake b/lib/tasks/gitlab/import.rake
index 6e10ba374bf..d227a0c8bdb 100644
--- a/lib/tasks/gitlab/import.rake
+++ b/lib/tasks/gitlab/import.rake
@@ -9,6 +9,7 @@ namespace :gitlab do
     #  * The project owner will set to the first administator of the system
     #  * Existing projects will be skipped
     #
+    #
     desc "GitLab | Import bare repositories from repositories -> storages into GitLab project instance"
     task repos: :environment do
       if Project.current_application_settings.hashed_storage_enabled
@@ -17,69 +18,7 @@ namespace :gitlab do
         exit 1
       end
 
-      Gitlab.config.repositories.storages.each_value do |repository_storage|
-        git_base_path = repository_storage['path']
-        repos_to_import = Dir.glob(git_base_path + '/**/*.git')
-
-        repos_to_import.each do |repo_path|
-          # strip repo base path
-          repo_path[0..git_base_path.length] = ''
-
-          path = repo_path.sub(/\.git$/, '')
-          group_name, name = File.split(path)
-          group_name = nil if group_name == '.'
-
-          puts "Processing #{repo_path}".color(:yellow)
-
-          if path.end_with?('.wiki')
-            puts " * Skipping wiki repo"
-            next
-          end
-
-          project = Project.find_by_full_path(path)
-
-          if project
-            puts " * #{project.name} (#{repo_path}) exists"
-          else
-            user = User.admins.reorder("id").first
-
-            project_params = {
-              name: name,
-              path: name
-            }
-
-            # find group namespace
-            if group_name
-              group = Namespace.find_by(path: group_name)
-              # create group namespace
-              unless group
-                group = Group.new(name: group_name)
-                group.path = group_name
-                group.owner = user
-                if group.save
-                  puts " * Created Group #{group.name} (#{group.id})".color(:green)
-                else
-                  puts " * Failed trying to create group #{group.name}".color(:red)
-                end
-              end
-              # set project group
-              project_params[:namespace_id] = group.id
-            end
-
-            project = Projects::CreateService.new(user, project_params).execute
-
-            if project.persisted?
-              puts " * Created #{project.name} (#{repo_path})".color(:green)
-              ProjectCacheWorker.perform_async(project.id)
-            else
-              puts " * Failed trying to create #{project.name} (#{repo_path})".color(:red)
-              puts "   Errors: #{project.errors.messages}".color(:red)
-            end
-          end
-        end
-      end
-
-      puts "Done!".color(:green)
+      Gitlab::BareRepositoryImporter.execute
     end
   end
 end
diff --git a/lib/tasks/gitlab/task_helpers.rb b/lib/tasks/gitlab/task_helpers.rb
index d85b810ac66..8a63f486fa3 100644
--- a/lib/tasks/gitlab/task_helpers.rb
+++ b/lib/tasks/gitlab/task_helpers.rb
@@ -104,7 +104,7 @@ module Gitlab
       Gitlab.config.gitlab.user
     end
 
-    def is_gitlab_user?
+    def gitlab_user?
       return @is_gitlab_user unless @is_gitlab_user.nil?
 
       current_user = run_command(%w(whoami)).chomp
@@ -114,7 +114,7 @@ module Gitlab
     def warn_user_is_not_gitlab
       return if @warned_user_not_gitlab
 
-      unless is_gitlab_user?
+      unless gitlab_user?
         current_user = run_command(%w(whoami)).chomp
 
         puts " Warning ".color(:black).background(:yellow)
diff --git a/lib/tasks/import.rake b/lib/tasks/import.rake
index 96b8f59242c..1206302cb76 100644
--- a/lib/tasks/import.rake
+++ b/lib/tasks/import.rake
@@ -72,23 +72,7 @@ class GithubImport
     return @current_user.namespace if names == @current_user.namespace_path
     return @current_user.namespace unless @current_user.can_create_group?
 
-    full_path_namespace = Namespace.find_by_full_path(names)
-
-    return full_path_namespace if full_path_namespace
-
-    names.split('/').inject(nil) do |parent, name|
-      begin
-        namespace = Group.create!(name: name,
-                                  path: name,
-                                  owner: @current_user,
-                                  parent: parent)
-        namespace.add_owner(@current_user)
-
-        namespace
-      rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid
-        Namespace.where(parent: parent).find_by_path_or_name(name)
-      end
-    end
+    Groups::NestedCreateService.new(@current_user, group_path: names).execute
   end
 
   def full_path_namespace(names)