Merge branch 'master' into zj-project-templates

* master: (623 commits)
  Fix issues with pdf-js dependencies
  fix missing changelog entries for security release on 2017-01-23
  Update top bar issues icon
  Fix pipeline icon in contextual nav for projects
  Since mysql is not a priority anymore, test it less
  Fix order of CI lint ace editor loading
  Add container registry and spam logs icons
  Fix different Markdown styles
  Backport to CE for:
  Make new dropdown dividers full width
  Fix spec
  Fix spec
  Fix spec
  Bump GITLAB_SHELL_VERSION and GITALY_VERSION to support unhiding refs
  Add changelog
  Install yarn via apt in update guides
  Use long curl options
  fix
  Add a spec for concurrent process
  Remove monkey-patched Array.prototype.first() and last() methods
  ...

28 files changed, 625 insertions, 382 deletions

diff --git a/app/services/ci/create_pipeline_service.rb b/app/services/ci/create_pipeline_service.rb
index 273386776fa..884b681ff81 100644
--- a/app/services/ci/create_pipeline_service.rb
+++ b/app/services/ci/create_pipeline_service.rb
@@ -15,12 +15,48 @@ module Ci
         pipeline_schedule: schedule
       )
 
+      result = validate(current_user || trigger_request.trigger.owner,
+                        ignore_skip_ci: ignore_skip_ci,
+                        save_on_errors: save_on_errors)
+
+      return result if result
+
+      begin
+        Ci::Pipeline.transaction do
+          pipeline.save!
+
+          yield(pipeline) if block_given?
+
+          Ci::CreatePipelineStagesService
+            .new(project, current_user)
+            .execute(pipeline)
+        end
+      rescue ActiveRecord::RecordInvalid => e
+        return error("Failed to persist the pipeline: #{e}")
+      end
+
+      update_merge_requests_head_pipeline
+
+      cancel_pending_pipelines if project.auto_cancel_pending_pipelines?
+
+      pipeline_created_counter.increment(source: source)
+
+      pipeline.tap(&:process!)
+    end
+
+    private
+
+    def validate(triggering_user, ignore_skip_ci:, save_on_errors:)
       unless project.builds_enabled?
         return error('Pipeline is disabled')
       end
 
-      unless trigger_request || can?(current_user, :create_pipeline, project)
-        return error('Insufficient permissions to create a new pipeline')
+      unless allowed_to_trigger_pipeline?(triggering_user)
+        if can?(triggering_user, :create_pipeline, project)
+          return error("Insufficient permissions for protected ref '#{ref}'")
+        else
+          return error('Insufficient permissions to create a new pipeline')
+        end
       end
 
       unless branch? || tag?
@@ -46,24 +82,29 @@ module Ci
       unless pipeline.has_stage_seeds?
         return error('No stages / jobs for this pipeline.')
       end
+    end
 
-      Ci::Pipeline.transaction do
-        update_merge_requests_head_pipeline if pipeline.save
-
-        Ci::CreatePipelineStagesService
-          .new(project, current_user)
-          .execute(pipeline)
+    def allowed_to_trigger_pipeline?(triggering_user)
+      if triggering_user
+        allowed_to_create?(triggering_user)
+      else # legacy triggers don't have a corresponding user
+        !project.protected_for?(ref)
       end
+    end
 
-      cancel_pending_pipelines if project.auto_cancel_pending_pipelines?
+    def allowed_to_create?(triggering_user)
+      access = Gitlab::UserAccess.new(triggering_user, project: project)
 
-      pipeline_created_counter.increment(source: source)
-
-      pipeline.tap(&:process!)
+      can?(triggering_user, :create_pipeline, project) &&
+        if branch?
+          access.can_update_branch?(ref)
+        elsif tag?
+          access.can_create_tag?(ref)
+        else
+          true # Allow it for now and we'll reject when we check ref existence
+        end
     end
 
-    private
-
     def update_merge_requests_head_pipeline
       return unless pipeline.latest?
 
@@ -113,15 +154,21 @@ module Ci
     end
 
     def branch?
-      project.repository.ref_exists?(Gitlab::Git::BRANCH_REF_PREFIX + ref)
+      return @is_branch if defined?(@is_branch)
+
+      @is_branch =
+        project.repository.ref_exists?(Gitlab::Git::BRANCH_REF_PREFIX + ref)
     end
 
     def tag?
-      project.repository.ref_exists?(Gitlab::Git::TAG_REF_PREFIX + ref)
+      return @is_tag if defined?(@is_tag)
+
+      @is_tag =
+        project.repository.ref_exists?(Gitlab::Git::TAG_REF_PREFIX + ref)
     end
 
     def ref
-      Gitlab::Git.ref_name(origin_ref)
+      @ref ||= Gitlab::Git.ref_name(origin_ref)
     end
 
     def valid_sha?
diff --git a/app/services/ci/create_trigger_request_service.rb b/app/services/ci/create_trigger_request_service.rb
index cf3d4aee2bc..b2aa457bbd5 100644
--- a/app/services/ci/create_trigger_request_service.rb
+++ b/app/services/ci/create_trigger_request_service.rb
@@ -1,12 +1,19 @@
+# This class is deprecated because we're closing Ci::TriggerRequest.
+# New class is PipelineTriggerService (app/services/ci/pipeline_trigger_service.rb)
+# which is integrated with Ci::PipelineVariable instaed of Ci::TriggerRequest.
+# We remove this class after we removed v1 and v3 API. This class is still being
+# referred by such legacy code.
 module Ci
-  class CreateTriggerRequestService
-    def execute(project, trigger, ref, variables = nil)
+  module CreateTriggerRequestService
+    Result = Struct.new(:trigger_request, :pipeline)
+
+    def self.execute(project, trigger, ref, variables = nil)
       trigger_request = trigger.trigger_requests.create(variables: variables)
 
       pipeline = Ci::CreatePipelineService.new(project, trigger.owner, ref: ref)
         .execute(:trigger, ignore_skip_ci: true, trigger_request: trigger_request)
 
-      trigger_request if pipeline.persisted?
+      Result.new(trigger_request, pipeline)
     end
   end
 end
diff --git a/app/services/ci/pipeline_trigger_service.rb b/app/services/ci/pipeline_trigger_service.rb
new file mode 100644
index 00000000000..1e5ad28ba57
--- /dev/null
+++ b/app/services/ci/pipeline_trigger_service.rb
@@ -0,0 +1,44 @@
+module Ci
+  class PipelineTriggerService < BaseService
+    def execute
+      if trigger_from_token
+        create_pipeline_from_trigger(trigger_from_token)
+      end
+    end
+
+    private
+
+    def create_pipeline_from_trigger(trigger)
+      # this check is to not leak the presence of the project if user cannot read it
+      return unless trigger.project == project
+
+      pipeline = Ci::CreatePipelineService.new(project, trigger.owner, ref: params[:ref])
+        .execute(:trigger, ignore_skip_ci: true) do |pipeline|
+          trigger.trigger_requests.create!(pipeline: pipeline)
+          create_pipeline_variables!(pipeline)
+        end
+
+      if pipeline.persisted?
+        success(pipeline: pipeline)
+      else
+        error(pipeline.errors.messages, 400)
+      end
+    end
+
+    def trigger_from_token
+      return @trigger if defined?(@trigger)
+
+      @trigger = Ci::Trigger.find_by_token(params[:token].to_s)
+    end
+
+    def create_pipeline_variables!(pipeline)
+      return unless params[:variables]
+
+      variables = params[:variables].map do |key, value|
+        { key: key, value: value }
+      end
+
+      pipeline.variables.create!(variables)
+    end
+  end
+end
diff --git a/app/services/delete_merged_branches_service.rb b/app/services/delete_merged_branches_service.rb
index 5c9e2a16c71..ff11bd59d29 100644
--- a/app/services/delete_merged_branches_service.rb
+++ b/app/services/delete_merged_branches_service.rb
@@ -11,7 +11,7 @@ class DeleteMergedBranchesService < BaseService
     # Prevent deletion of branches relevant to open merge requests
     branches -= merge_request_branch_names
     # Prevent deletion of protected branches
-    branches -= project.protected_branches.pluck(:name)
+    branches = branches.reject { |branch| project.protected_for?(branch) }
 
     branches.each do |branch|
       DeleteBranchService.new(project, current_user).execute(branch)
diff --git a/app/services/git_operation_service.rb b/app/services/git_operation_service.rb
index 32925e9c1f2..545ca0742e4 100644
--- a/app/services/git_operation_service.rb
+++ b/app/services/git_operation_service.rb
@@ -60,7 +60,7 @@ class GitOperationService
     start_branch_name = nil if start_repository.empty_repo?
 
     if start_branch_name && !start_repository.branch_exists?(start_branch_name)
-      raise ArgumentError, "Cannot find branch #{start_branch_name} in #{start_repository.path_with_namespace}"
+      raise ArgumentError, "Cannot find branch #{start_branch_name} in #{start_repository.full_path}"
     end
 
     update_branch_with_hooks(branch_name) do
diff --git a/app/services/git_push_service.rb b/app/services/git_push_service.rb
index 20d1fb29289..ada2b64a3a6 100644
--- a/app/services/git_push_service.rb
+++ b/app/services/git_push_service.rb
@@ -45,6 +45,7 @@ class GitPushService < BaseService
     elsif push_to_existing_branch?
       # Collect data for this git push
       @push_commits = @project.repository.commits_between(params[:oldrev], params[:newrev])
+
       process_commit_messages
 
       # Update the bare repositories info/attributes file using the contents of the default branches
@@ -56,6 +57,8 @@ class GitPushService < BaseService
     perform_housekeeping
 
     update_caches
+
+    update_signatures
   end
 
   def update_gitattributes
@@ -64,15 +67,21 @@ class GitPushService < BaseService
 
   def update_caches
     if is_default_branch?
-      paths = Set.new
+      if push_to_new_branch?
+        # If this is the initial push into the default branch, the file type caches
+        # will already be reset as a result of `Project#change_head`.
+        types = []
+      else
+        paths = Set.new
 
-      @push_commits.each do |commit|
-        commit.raw_deltas.each do |diff|
-          paths << diff.new_path
+        @push_commits.last(PROCESS_COMMIT_LIMIT).each do |commit|
+          commit.raw_deltas.each do |diff|
+            paths << diff.new_path
+          end
         end
-      end
 
-      types = Gitlab::FileDetector.types_in_paths(paths.to_a)
+        types = Gitlab::FileDetector.types_in_paths(paths.to_a)
+      end
     else
       types = []
     end
@@ -80,11 +89,17 @@ class GitPushService < BaseService
     ProjectCacheWorker.perform_async(@project.id, types, [:commit_count, :repository_size])
   end
 
+  def update_signatures
+    @push_commits.each do |commit|
+      CreateGpgSignatureWorker.perform_async(commit.sha, @project.id)
+    end
+  end
+
   # Schedules processing of commit messages.
   def process_commit_messages
     default = is_default_branch?
 
-    push_commits.last(PROCESS_COMMIT_LIMIT).each do |commit|
+    @push_commits.last(PROCESS_COMMIT_LIMIT).each do |commit|
       if commit.matches_cross_reference_regex?
         ProcessCommitWorker
           .perform_async(project.id, current_user.id, commit.to_hash, default)
@@ -103,7 +118,7 @@ class GitPushService < BaseService
 
     EventCreateService.new.push(@project, current_user, build_push_data)
     Ci::CreatePipelineService.new(@project, current_user, build_push_data).execute(:push)
-    
+
     SystemHookPushWorker.perform_async(build_push_data.dup, :push_hooks)
     @project.execute_hooks(build_push_data.dup, :push_hooks)
     @project.execute_services(build_push_data.dup, :push_hooks)
@@ -123,7 +138,10 @@ class GitPushService < BaseService
   end
 
   def process_default_branch
-    @push_commits = project.repository.commits(params[:newrev])
+    @push_commits_count = project.repository.commit_count_for_ref(params[:ref])
+
+    offset = [@push_commits_count - PROCESS_COMMIT_LIMIT, 0].max
+    @push_commits = project.repository.commits(params[:newrev], offset: offset, limit: PROCESS_COMMIT_LIMIT)
 
     # Ensure HEAD points to the default branch in case it is not master
     project.change_head(branch_name)
@@ -152,7 +170,8 @@ class GitPushService < BaseService
       params[:oldrev],
       params[:newrev],
       params[:ref],
-      push_commits)
+      @push_commits,
+      commits_count: @push_commits_count)
   end
 
   def push_to_existing_branch?
diff --git a/app/services/groups/destroy_service.rb b/app/services/groups/destroy_service.rb
index 80c51cb5a72..f565612a89d 100644
--- a/app/services/groups/destroy_service.rb
+++ b/app/services/groups/destroy_service.rb
@@ -21,6 +21,8 @@ module Groups
         DestroyService.new(group, current_user).execute
       end
 
+      group.chat_team&.remove_mattermost_team(current_user)
+
       group.really_destroy!
     end
   end
diff --git a/app/services/issuable_base_service.rb b/app/services/issuable_base_service.rb
index 9078b1f0983..760a15e3ed0 100644
--- a/app/services/issuable_base_service.rb
+++ b/app/services/issuable_base_service.rb
@@ -58,6 +58,7 @@ class IssuableBaseService < BaseService
       params.delete(:assignee_ids)
       params.delete(:assignee_id)
       params.delete(:due_date)
+      params.delete(:canonical_issue_id)
     end
 
     filter_assignee(issuable)
@@ -287,7 +288,7 @@ class IssuableBaseService < BaseService
       todo_service.mark_todo(issuable, current_user)
     when 'done'
       todo = TodosFinder.new(current_user).execute.find_by(target: issuable)
-      todo_service.mark_todos_as_done([todo], current_user) if todo
+      todo_service.mark_todos_as_done_by_ids(todo, current_user) if todo
     end
   end
 
diff --git a/app/services/issues/base_service.rb b/app/services/issues/base_service.rb
index 34199eb5d13..4c198fc96ea 100644
--- a/app/services/issues/base_service.rb
+++ b/app/services/issues/base_service.rb
@@ -7,6 +7,14 @@ module Issues
       issue_data
     end
 
+    def reopen_service
+      Issues::ReopenService
+    end
+
+    def close_service
+      Issues::CloseService
+    end
+
     private
 
     def create_assignee_note(issue, old_assignees)
diff --git a/app/services/issues/duplicate_service.rb b/app/services/issues/duplicate_service.rb
new file mode 100644
index 00000000000..5c0854e664d
--- /dev/null
+++ b/app/services/issues/duplicate_service.rb
@@ -0,0 +1,24 @@
+module Issues
+  class DuplicateService < Issues::BaseService
+    def execute(duplicate_issue, canonical_issue)
+      return if canonical_issue == duplicate_issue
+      return unless can?(current_user, :update_issue, duplicate_issue)
+      return unless can?(current_user, :create_note, canonical_issue)
+
+      create_issue_duplicate_note(duplicate_issue, canonical_issue)
+      create_issue_canonical_note(canonical_issue, duplicate_issue)
+
+      close_service.new(project, current_user, {}).execute(duplicate_issue)
+    end
+
+    private
+
+    def create_issue_duplicate_note(duplicate_issue, canonical_issue)
+      SystemNoteService.mark_duplicate_issue(duplicate_issue, duplicate_issue.project, current_user, canonical_issue)
+    end
+
+    def create_issue_canonical_note(canonical_issue, duplicate_issue)
+      SystemNoteService.mark_canonical_issue_of_duplicate(canonical_issue, canonical_issue.project, current_user, duplicate_issue)
+    end
+  end
+end
diff --git a/app/services/issues/reopen_service.rb b/app/services/issues/reopen_service.rb
index 73b2e85cba3..35de4337b15 100644
--- a/app/services/issues/reopen_service.rb
+++ b/app/services/issues/reopen_service.rb
@@ -5,7 +5,7 @@ module Issues
 
       if issue.reopen
         event_service.reopen_issue(issue, current_user)
-        create_note(issue)
+        create_note(issue, 'reopened')
         notification_service.reopen_issue(issue, current_user)
         execute_hooks(issue, 'reopen')
         invalidate_cache_counts(issue, users: issue.assignees)
@@ -16,8 +16,8 @@ module Issues
 
     private
 
-    def create_note(issue)
-      SystemNoteService.change_status(issue, issue.project, current_user, issue.state, nil)
+    def create_note(issue, state = issue.state)
+      SystemNoteService.change_status(issue, issue.project, current_user, state, nil)
     end
   end
 end
diff --git a/app/services/issues/update_service.rb b/app/services/issues/update_service.rb
index cd9f9a4a16e..8d918ccc635 100644
--- a/app/services/issues/update_service.rb
+++ b/app/services/issues/update_service.rb
@@ -5,6 +5,7 @@ module Issues
     def execute(issue)
       handle_move_between_iids(issue)
       filter_spam_check_params
+      change_issue_duplicate(issue)
       update(issue)
     end
 
@@ -53,14 +54,6 @@ module Issues
       end
     end
 
-    def reopen_service
-      Issues::ReopenService
-    end
-
-    def close_service
-      Issues::CloseService
-    end
-
     def handle_move_between_iids(issue)
       return unless params[:move_between_iids]
 
@@ -72,6 +65,15 @@ module Issues
       issue.move_between(issue_before, issue_after)
     end
 
+    def change_issue_duplicate(issue)
+      canonical_issue_id = params.delete(:canonical_issue_id)
+      canonical_issue = IssuesFinder.new(current_user).find_by(id: canonical_issue_id)
+
+      if canonical_issue
+        Issues::DuplicateService.new(project, current_user).execute(issue, canonical_issue)
+      end
+    end
+
     private
 
     def get_issue_if_allowed(project, iid)
diff --git a/app/services/merge_requests/base_service.rb b/app/services/merge_requests/base_service.rb
index 3542a41ac83..35ccff26262 100644
--- a/app/services/merge_requests/base_service.rb
+++ b/app/services/merge_requests/base_service.rb
@@ -1,7 +1,7 @@
 module MergeRequests
   class BaseService < ::IssuableBaseService
-    def create_note(merge_request)
-      SystemNoteService.change_status(merge_request, merge_request.target_project, current_user, merge_request.state, nil)
+    def create_note(merge_request, state = merge_request.state)
+      SystemNoteService.change_status(merge_request, merge_request.target_project, current_user, state, nil)
     end
 
     def create_title_change_note(issuable, old_title)
@@ -44,7 +44,7 @@ module MergeRequests
     end
 
     # Returns all origin and fork merge requests from `@project` satisfying passed arguments.
-    def merge_requests_for(source_branch, mr_states: [:opened, :reopened])
+    def merge_requests_for(source_branch, mr_states: [:opened])
       MergeRequest
         .with_state(mr_states)
         .where(source_branch: source_branch, source_project_id: @project.id)
diff --git a/app/services/merge_requests/create_service.rb b/app/services/merge_requests/create_service.rb
index 19189e64acf..5414fa79def 100644
--- a/app/services/merge_requests/create_service.rb
+++ b/app/services/merge_requests/create_service.rb
@@ -12,7 +12,6 @@ module MergeRequests
       merge_request.source_project = source_project
       merge_request.source_branch = params[:source_branch]
       merge_request.merge_params['force_remove_source_branch'] = params.delete(:force_remove_source_branch)
-      merge_request.head_pipeline = head_pipeline_for(merge_request)
 
       create(merge_request)
     end
@@ -22,10 +21,16 @@ module MergeRequests
       notification_service.new_merge_request(issuable, current_user)
       todo_service.new_merge_request(issuable, current_user)
       issuable.cache_merge_request_closes_issues!(current_user)
+      update_merge_requests_head_pipeline(issuable)
     end
 
     private
 
+    def update_merge_requests_head_pipeline(merge_request)
+      pipeline = head_pipeline_for(merge_request)
+      merge_request.update(head_pipeline_id: pipeline.id) if pipeline
+    end
+
     def head_pipeline_for(merge_request)
       return unless merge_request.source_project
 
diff --git a/app/services/merge_requests/reopen_service.rb b/app/services/merge_requests/reopen_service.rb
index 52f6d511f98..b9c65be36ec 100644
--- a/app/services/merge_requests/reopen_service.rb
+++ b/app/services/merge_requests/reopen_service.rb
@@ -5,7 +5,7 @@ module MergeRequests
 
       if merge_request.reopen
         event_service.reopen_mr(merge_request, current_user)
-        create_note(merge_request)
+        create_note(merge_request, 'reopened')
         notification_service.reopen_mr(merge_request, current_user)
         execute_hooks(merge_request, 'reopen')
         merge_request.reload_diff(current_user)
diff --git a/app/services/notification_recipient_service.rb b/app/services/notification_recipient_service.rb
index 9ac561e4bd2..21c9c314a2a 100644
--- a/app/services/notification_recipient_service.rb
+++ b/app/services/notification_recipient_service.rb
@@ -1,331 +1,288 @@
 #
 # Used by NotificationService to determine who should receive notification
 #
-class NotificationRecipientService
-  attr_reader :project
-
-  def initialize(project)
-    @project = project
+module NotificationRecipientService
+  def self.notifiable_users(users, *args)
+    users.compact.map { |u| NotificationRecipient.new(u, *args) }.select(&:notifiable?).map(&:user)
   end
 
-  def build_recipients(target, current_user, action:, previous_assignee: nil, skip_current_user: true)
-    custom_action = build_custom_key(action, target)
-
-    recipients = participants(target, current_user)
-    recipients = add_project_watchers(recipients)
-    recipients = add_custom_notifications(recipients, custom_action)
-    recipients = reject_mention_users(recipients)
-
-    # Re-assign is considered as a mention of the new assignee so we add the
-    # new assignee to the list of recipients after we rejected users with
-    # the "on mention" notification level
-    case custom_action
-    when :reassign_merge_request
-      recipients << previous_assignee if previous_assignee
-      recipients << target.assignee
-    when :reassign_issue
-      previous_assignees = Array(previous_assignee)
-      recipients.concat(previous_assignees)
-      recipients.concat(target.assignees)
-    end
-
-    recipients = reject_muted_users(recipients)
-    recipients = add_subscribed_users(recipients, target)
-
-    if [:new_issue, :new_merge_request].include?(custom_action)
-      recipients = add_labels_subscribers(recipients, target)
-    end
-
-    recipients = reject_unsubscribed_users(recipients, target)
-    recipients = reject_users_without_access(recipients, target)
+  def self.notifiable?(user, *args)
+    NotificationRecipient.new(user, *args).notifiable?
+  end
 
-    recipients.delete(current_user) if skip_current_user && !current_user.notified_of_own_activity?
+  def self.build_recipients(*a)
+    Builder::Default.new(*a).recipient_users
+  end
 
-    recipients.uniq
+  def self.build_new_note_recipients(*a)
+    Builder::NewNote.new(*a).recipient_users
   end
 
-  def build_pipeline_recipients(target, current_user, action:)
-    return [] unless current_user
+  module Builder
+    class Base
+      def initialize(*)
+        raise 'abstract'
+      end
 
-    custom_action =
-      case action.to_s
-      when 'failed'
-        :failed_pipeline
-      when 'success'
-        :success_pipeline
+      def build!
+        raise 'abstract'
       end
 
-    notification_setting = notification_setting_for_user_project(current_user, target.project)
+      def filter!
+        recipients.select!(&:notifiable?)
+      end
 
-    return [] if notification_setting.mention? || notification_setting.disabled?
+      def acting_user
+        current_user
+      end
 
-    return [] if notification_setting.custom? && !notification_setting.event_enabled?(custom_action)
+      def target
+        raise 'abstract'
+      end
 
-    return [] if (notification_setting.watch? || notification_setting.participating?) && NotificationSetting::EXCLUDED_WATCHER_EVENTS.include?(custom_action)
+      # rubocop:disable Rails/Delegate
+      def project
+        target.project
+      end
 
-    reject_users_without_access([current_user], target)
-  end
+      def recipients
+        @recipients ||= []
+      end
 
-  def build_relabeled_recipients(target, current_user, labels:)
-    recipients = add_labels_subscribers([], target, labels: labels)
-    recipients = reject_unsubscribed_users(recipients, target)
-    recipients = reject_users_without_access(recipients, target)
-    recipients.delete(current_user) unless current_user.notified_of_own_activity?
-    recipients.uniq
-  end
+      def <<(pair)
+        users, type = pair
 
-  def build_new_note_recipients(note)
-    target = note.noteable
+        if users.is_a?(ActiveRecord::Relation)
+          users = users.includes(:notification_settings)
+        end
 
-    ability, subject = if note.for_personal_snippet?
-                         [:read_personal_snippet, note.noteable]
-                       else
-                         [:read_project, note.project]
-                       end
+        users = Array(users)
+        users.compact!
+        recipients.concat(users.map { |u| make_recipient(u, type) })
+      end
 
-    mentioned_users = note.mentioned_users.select { |user| user.can?(ability, subject) }
+      def user_scope
+        User.includes(:notification_settings)
+      end
 
-    # Add all users participating in the thread (author, assignee, comment authors)
-    recipients = participants(target, note.author) || mentioned_users
+      def make_recipient(user, type)
+        NotificationRecipient.new(
+          user, type,
+          project: project,
+          custom_action: custom_action,
+          target: target,
+          acting_user: acting_user
+        )
+      end
 
-    unless note.for_personal_snippet?
-      # Merge project watchers
-      recipients = add_project_watchers(recipients)
+      def recipient_users
+        @recipient_users ||=
+          begin
+            build!
+            filter!
+            users = recipients.map(&:user)
+            users.uniq!
+            users.freeze
+          end
+      end
 
-      # Merge project with custom notification
-      recipients = add_custom_notifications(recipients, :new_note)
-    end
+      def custom_action
+        nil
+      end
 
-    # Reject users with Mention notification level, except those mentioned in _this_ note.
-    recipients = reject_mention_users(recipients - mentioned_users)
-    recipients = recipients + mentioned_users
+      protected
 
-    recipients = reject_muted_users(recipients)
+      def add_participants(user)
+        return unless target.respond_to?(:participants)
 
-    recipients = add_subscribed_users(recipients, note.noteable)
-    recipients = reject_unsubscribed_users(recipients, note.noteable)
-    recipients = reject_users_without_access(recipients, note.noteable)
+        self << [target.participants(user), :watch]
+      end
 
-    recipients.delete(note.author) unless note.author.notified_of_own_activity?
-    recipients.uniq
-  end
+      # Get project/group users with CUSTOM notification level
+      def add_custom_notifications
+        user_ids = []
 
-  # Remove users with disabled notifications from array
-  # Also remove duplications and nil recipients
-  def reject_muted_users(users)
-    reject_users(users, :disabled)
-  end
+        # Users with a notification setting on group or project
+        user_ids += user_ids_notifiable_on(project, :custom)
+        user_ids += user_ids_notifiable_on(project.group, :custom)
 
-  protected
+        # Users with global level custom
+        user_ids_with_project_level_global = user_ids_notifiable_on(project, :global)
+        user_ids_with_group_level_global   = user_ids_notifiable_on(project.group, :global)
 
-  # Ensure that if we modify this array, we aren't modifying the memoised
-  # participants on the target.
-  def participants(target, user)
-    return unless target.respond_to?(:participants)
+        global_users_ids = user_ids_with_project_level_global.concat(user_ids_with_group_level_global)
+        user_ids += user_ids_with_global_level_custom(global_users_ids, custom_action)
 
-    target.participants(user).dup
-  end
+        self << [user_scope.where(id: user_ids), :watch]
+      end
 
-  # Get project/group users with CUSTOM notification level
-  def add_custom_notifications(recipients, action)
-    user_ids = []
+      def add_project_watchers
+        self << [project_watchers, :watch]
+      end
 
-    # Users with a notification setting on group or project
-    user_ids += user_ids_notifiable_on(project, :custom, action)
-    user_ids += user_ids_notifiable_on(project.group, :custom, action)
+      # Get project users with WATCH notification level
+      def project_watchers
+        project_members_ids = user_ids_notifiable_on(project)
 
-    # Users with global level custom
-    user_ids_with_project_level_global = user_ids_notifiable_on(project, :global)
-    user_ids_with_group_level_global   = user_ids_notifiable_on(project.group, :global)
+        user_ids_with_project_global = user_ids_notifiable_on(project, :global)
+        user_ids_with_group_global   = user_ids_notifiable_on(project.group, :global)
 
-    global_users_ids = user_ids_with_project_level_global.concat(user_ids_with_group_level_global)
-    user_ids += user_ids_with_global_level_custom(global_users_ids, action)
+        user_ids = user_ids_with_global_level_watch((user_ids_with_project_global + user_ids_with_group_global).uniq)
 
-    recipients.concat(User.find(user_ids))
-  end
+        user_ids_with_project_setting = select_project_members_ids(user_ids_with_project_global, user_ids)
+        user_ids_with_group_setting = select_group_members_ids(project.group, project_members_ids, user_ids_with_group_global, user_ids)
 
-  def add_project_watchers(recipients)
-    recipients.concat(project_watchers).compact
-  end
+        user_scope.where(id: user_ids_with_project_setting.concat(user_ids_with_group_setting).uniq)
+      end
 
-  # Get project users with WATCH notification level
-  def project_watchers
-    project_members_ids = user_ids_notifiable_on(project)
+      def add_subscribed_users
+        return unless target.respond_to? :subscribers
 
-    user_ids_with_project_global = user_ids_notifiable_on(project, :global)
-    user_ids_with_group_global   = user_ids_notifiable_on(project.group, :global)
+        self << [target.subscribers(project), :subscription]
+      end
 
-    user_ids = user_ids_with_global_level_watch((user_ids_with_project_global + user_ids_with_group_global).uniq)
+      def user_ids_notifiable_on(resource, notification_level = nil)
+        return [] unless resource
 
-    user_ids_with_project_setting = select_project_members_ids(project, user_ids_with_project_global, user_ids)
-    user_ids_with_group_setting = select_group_members_ids(project.group, project_members_ids, user_ids_with_group_global, user_ids)
+        scope = resource.notification_settings
 
-    User.where(id: user_ids_with_project_setting.concat(user_ids_with_group_setting).uniq).to_a
-  end
+        if notification_level
+          scope = scope.where(level: NotificationSetting.levels[notification_level])
+        end
 
-  # Remove users with notification level 'Mentioned'
-  def reject_mention_users(users)
-    reject_users(users, :mention)
-  end
+        scope.pluck(:user_id)
+      end
 
-  def add_subscribed_users(recipients, target)
-    return recipients unless target.respond_to? :subscribers
+      # Build a list of user_ids based on project notification settings
+      def select_project_members_ids(global_setting, user_ids_global_level_watch)
+        user_ids = user_ids_notifiable_on(project, :watch)
 
-    recipients + target.subscribers(project)
-  end
+        # If project setting is global, add to watch list if global setting is watch
+        user_ids + (global_setting & user_ids_global_level_watch)
+      end
 
-  def user_ids_notifiable_on(resource, notification_level = nil, action = nil)
-    return [] unless resource
+      # Build a list of user_ids based on group notification settings
+      def select_group_members_ids(group, project_members, global_setting, user_ids_global_level_watch)
+        uids = user_ids_notifiable_on(group, :watch)
 
-    if notification_level
-      settings = resource.notification_settings.where(level: NotificationSetting.levels[notification_level])
-      settings = settings.select { |setting| setting.event_enabled?(action) } if action.present?
-      settings.map(&:user_id)
-    else
-      resource.notification_settings.pluck(:user_id)
-    end
-  end
+        # Group setting is global, add to user_ids list if global setting is watch
+        uids + (global_setting & user_ids_global_level_watch) - project_members
+      end
 
-  # Build a list of user_ids based on project notification settings
-  def select_project_members_ids(project, global_setting, user_ids_global_level_watch)
-    user_ids = user_ids_notifiable_on(project, :watch)
+      def user_ids_with_global_level_watch(ids)
+        settings_with_global_level_of(:watch, ids).pluck(:user_id)
+      end
 
-    # If project setting is global, add to watch list if global setting is watch
-    global_setting.each do |user_id|
-      if user_ids_global_level_watch.include?(user_id)
-        user_ids << user_id
+      def user_ids_with_global_level_custom(ids, action)
+        settings_with_global_level_of(:custom, ids).pluck(:user_id)
       end
-    end
 
-    user_ids
-  end
+      def settings_with_global_level_of(level, ids)
+        NotificationSetting.where(
+          user_id: ids,
+          source_type: nil,
+          level: NotificationSetting.levels[level]
+        )
+      end
 
-  # Build a list of user_ids based on group notification settings
-  def select_group_members_ids(group, project_members, global_setting, user_ids_global_level_watch)
-    uids = user_ids_notifiable_on(group, :watch)
+      def add_labels_subscribers(labels: nil)
+        return unless target.respond_to? :labels
 
-    # Group setting is watch, add to user_ids list if user is not project member
-    user_ids = []
-    uids.each do |user_id|
-      if project_members.exclude?(user_id)
-        user_ids << user_id
+        (labels || target.labels).each do |label|
+          self << [label.subscribers(project), :subscription]
+        end
       end
     end
 
-    # Group setting is global, add to user_ids list if global setting is watch
-    global_setting.each do |user_id|
-      if project_members.exclude?(user_id) && user_ids_global_level_watch.include?(user_id)
-        user_ids << user_id
+    class Default < Base
+      attr_reader :target
+      attr_reader :current_user
+      attr_reader :action
+      attr_reader :previous_assignee
+      attr_reader :skip_current_user
+      def initialize(target, current_user, action:, previous_assignee: nil, skip_current_user: true)
+        @target = target
+        @current_user = current_user
+        @action = action
+        @previous_assignee = previous_assignee
+        @skip_current_user = skip_current_user
       end
-    end
-
-    user_ids
-  end
-
-  def user_ids_with_global_level_watch(ids)
-    settings_with_global_level_of(:watch, ids).pluck(:user_id)
-  end
-
-  def user_ids_with_global_level_custom(ids, action)
-    settings = settings_with_global_level_of(:custom, ids)
-    settings = settings.select { |setting| setting.event_enabled?(action) }
-    settings.map(&:user_id)
-  end
 
-  def settings_with_global_level_of(level, ids)
-    NotificationSetting.where(
-      user_id: ids,
-      source_type: nil,
-      level: NotificationSetting.levels[level]
-    )
-  end
+      def build!
+        add_participants(current_user)
+        add_project_watchers
+        add_custom_notifications
+
+        # Re-assign is considered as a mention of the new assignee
+        case custom_action
+        when :reassign_merge_request
+          self << [previous_assignee, :mention]
+          self << [target.assignee, :mention]
+        when :reassign_issue
+          previous_assignees = Array(previous_assignee)
+          self << [previous_assignees, :mention]
+          self << [target.assignees, :mention]
+        end
+
+        add_subscribed_users
+
+        if [:new_issue, :new_merge_request].include?(custom_action)
+          add_labels_subscribers
+        end
+      end
 
-  # Reject users which has certain notification level
-  #
-  # Example:
-  #   reject_users(users, :watch, project)
-  #
-  def reject_users(users, level)
-    level = level.to_s
+      def acting_user
+        current_user if skip_current_user
+      end
 
-    unless NotificationSetting.levels.keys.include?(level)
-      raise 'Invalid notification level'
+      # Build event key to search on custom notification level
+      # Check NotificationSetting::EMAIL_EVENTS
+      def custom_action
+        @custom_action ||= "#{action}_#{target.class.model_name.name.underscore}".to_sym
+      end
     end
 
-    users = users.to_a.compact.uniq
-    users = users.select { |u| u.can?(:receive_notifications) }
-
-    users.reject do |user|
-      global_notification_setting = user.global_notification_setting
-
-      next global_notification_setting.level == level unless project
-
-      setting = user.notification_settings_for(project)
-
-      if project.group && (setting.nil? || setting.global?)
-        setting = user.notification_settings_for(project.group)
+    class NewNote < Base
+      attr_reader :note
+      def initialize(note)
+        @note = note
       end
 
-      # reject users who globally set mention notification and has no setting per project/group
-      next global_notification_setting.level == level unless setting
-
-      # reject users who set mention notification in project
-      next true if setting.level == level
-
-      # reject users who have mention level in project and disabled in global settings
-      setting.global? && global_notification_setting.level == level
-    end
-  end
+      def target
+        note.noteable
+      end
 
-  def reject_unsubscribed_users(recipients, target)
-    return recipients unless target.respond_to? :subscriptions
+      # NOTE: may be nil, in the case of a PersonalSnippet
+      #
+      # (this is okay because NotificationRecipient is written
+      # to handle nil projects)
+      def project
+        note.project
+      end
 
-    recipients.reject do |user|
-      subscription = target.subscriptions.find_by_user_id(user.id)
-      subscription && !subscription.subscribed
-    end
-  end
+      def build!
+        # Add all users participating in the thread (author, assignee, comment authors)
+        add_participants(note.author)
+        self << [note.mentioned_users, :mention]
 
-  def reject_users_without_access(recipients, target)
-    ability = case target
-              when Issuable
-                :"read_#{target.to_ability_name}"
-              when Ci::Pipeline
-                :read_build # We have build trace in pipeline emails
-              end
+        unless note.for_personal_snippet?
+          # Merge project watchers
+          add_project_watchers
 
-    return recipients unless ability
+          # Merge project with custom notification
+          add_custom_notifications
+        end
 
-    recipients.select do |user|
-      user.can?(ability, target)
-    end
-  end
+        add_subscribed_users
+      end
 
-  def add_labels_subscribers(recipients, target, labels: nil)
-    return recipients unless target.respond_to? :labels
+      def custom_action
+        :new_note
+      end
 
-    (labels || target.labels).each do |label|
-      recipients += label.subscribers(project)
+      def acting_user
+        note.author
+      end
     end
-
-    recipients
-  end
-
-  # Build event key to search on custom notification level
-  # Check NotificationSetting::EMAIL_EVENTS
-  def build_custom_key(action, object)
-    "#{action}_#{object.class.model_name.name.underscore}".to_sym
-  end
-
-  def notification_setting_for_user_project(user, project)
-    project_setting = user.notification_settings_for(project)
-
-    return project_setting unless project_setting.global?
-
-    group_setting = user.notification_settings_for(project.group)
-
-    return group_setting unless group_setting.global?
-
-    user.global_notification_setting
   end
 end
diff --git a/app/services/notification_service.rb b/app/services/notification_service.rb
index 3a98a5f6b64..df04b1a4fe3 100644
--- a/app/services/notification_service.rb
+++ b/app/services/notification_service.rb
@@ -17,6 +17,16 @@ class NotificationService
     end
   end
 
+  # Always notify the user about gpg key added
+  #
+  # This is a security email so it will be sent even if the user user disabled
+  # notifications
+  def new_gpg_key(gpg_key)
+    if gpg_key.user
+      mailer.new_gpg_key_email(gpg_key.id).deliver_later
+    end
+  end
+
   # Always notify user about email added to profile
   def new_email(email)
     if email.user
@@ -32,7 +42,7 @@ class NotificationService
   #  * users with custom level checked with "new issue"
   #
   def new_issue(issue, current_user)
-    new_resource_email(issue, issue.project, :new_issue_email)
+    new_resource_email(issue, :new_issue_email)
   end
 
   # When issue text is updated, we should send an email to:
@@ -42,7 +52,6 @@ class NotificationService
   def new_mentions_in_issue(issue, new_mentioned_users, current_user)
     new_mentions_in_resource_email(
       issue,
-      issue.project,
       new_mentioned_users,
       current_user,
       :new_mention_in_issue_email
@@ -57,7 +66,7 @@ class NotificationService
   #  * users with custom level checked with "close issue"
   #
   def close_issue(issue, current_user)
-    close_resource_email(issue, issue.project, current_user, :closed_issue_email)
+    close_resource_email(issue, current_user, :closed_issue_email)
   end
 
   # When we reassign an issue we should send an email to:
@@ -67,7 +76,7 @@ class NotificationService
   #  * users with custom level checked with "reassign issue"
   #
   def reassigned_issue(issue, current_user, previous_assignees = [])
-    recipients = NotificationRecipientService.new(issue.project).build_recipients(
+    recipients = NotificationRecipientService.build_recipients(
       issue,
       current_user,
       action: "reassign",
@@ -92,7 +101,7 @@ class NotificationService
   #  * watchers of the issue's labels
   #
   def relabeled_issue(issue, added_labels, current_user)
-    relabeled_resource_email(issue, issue.project, added_labels, current_user, :relabeled_issue_email)
+    relabeled_resource_email(issue, added_labels, current_user, :relabeled_issue_email)
   end
 
   # When create a merge request we should send an email to:
@@ -103,7 +112,7 @@ class NotificationService
   #  * users with custom level checked with "new merge request"
   #
   def new_merge_request(merge_request, current_user)
-    new_resource_email(merge_request, merge_request.target_project, :new_merge_request_email)
+    new_resource_email(merge_request, :new_merge_request_email)
   end
 
   # When merge request text is updated, we should send an email to:
@@ -113,7 +122,6 @@ class NotificationService
   def new_mentions_in_merge_request(merge_request, new_mentioned_users, current_user)
     new_mentions_in_resource_email(
       merge_request,
-      merge_request.target_project,
       new_mentioned_users,
       current_user,
       :new_mention_in_merge_request_email
@@ -127,7 +135,7 @@ class NotificationService
   #  * users with custom level checked with "reassign merge request"
   #
   def reassigned_merge_request(merge_request, current_user)
-    reassign_resource_email(merge_request, merge_request.target_project, current_user, :reassigned_merge_request_email)
+    reassign_resource_email(merge_request, current_user, :reassigned_merge_request_email)
   end
 
   # When we add labels to a merge request we should send an email to:
@@ -135,21 +143,20 @@ class NotificationService
   #  * watchers of the mr's labels
   #
   def relabeled_merge_request(merge_request, added_labels, current_user)
-    relabeled_resource_email(merge_request, merge_request.target_project, added_labels, current_user, :relabeled_merge_request_email)
+    relabeled_resource_email(merge_request, added_labels, current_user, :relabeled_merge_request_email)
   end
 
   def close_mr(merge_request, current_user)
-    close_resource_email(merge_request, merge_request.target_project, current_user, :closed_merge_request_email)
+    close_resource_email(merge_request, current_user, :closed_merge_request_email)
   end
 
   def reopen_issue(issue, current_user)
-    reopen_resource_email(issue, issue.project, current_user, :issue_status_changed_email, 'reopened')
+    reopen_resource_email(issue, current_user, :issue_status_changed_email, 'reopened')
   end
 
   def merge_mr(merge_request, current_user)
     close_resource_email(
       merge_request,
-      merge_request.target_project,
       current_user,
       :merged_merge_request_email,
       skip_current_user: !merge_request.merge_when_pipeline_succeeds?
@@ -159,7 +166,6 @@ class NotificationService
   def reopen_mr(merge_request, current_user)
     reopen_resource_email(
       merge_request,
-      merge_request.target_project,
       current_user,
       :merge_request_status_email,
       'reopened'
@@ -167,7 +173,7 @@ class NotificationService
   end
 
   def resolve_all_discussions(merge_request, current_user)
-    recipients = NotificationRecipientService.new(merge_request.target_project).build_recipients(
+    recipients = NotificationRecipientService.build_recipients(
       merge_request,
       current_user,
       action: "resolve_all_discussions")
@@ -192,7 +198,7 @@ class NotificationService
 
     notify_method = "note_#{note.to_ability_name}_email".to_sym
 
-    recipients = NotificationRecipientService.new(note.project).build_new_note_recipients(note)
+    recipients = NotificationRecipientService.build_new_note_recipients(note)
     recipients.each do |recipient|
       mailer.send(notify_method, recipient.id, note.id).deliver_later
     end
@@ -260,8 +266,7 @@ class NotificationService
   end
 
   def project_was_moved(project, old_path_with_namespace)
-    recipients = project.team.members
-    recipients = NotificationRecipientService.new(project).reject_muted_users(recipients)
+    recipients = NotificationRecipientService.notifiable_users(project.team.members, :mention, project: project)
 
     recipients.each do |recipient|
       mailer.project_was_moved_email(
@@ -273,7 +278,7 @@ class NotificationService
   end
 
   def issue_moved(issue, new_issue, current_user)
-    recipients = NotificationRecipientService.new(issue.project).build_recipients(issue, current_user, action: 'moved')
+    recipients = NotificationRecipientService.build_recipients(issue, current_user, action: 'moved')
 
     recipients.map do |recipient|
       email = mailer.issue_moved_email(recipient, issue, new_issue, current_user)
@@ -295,10 +300,10 @@ class NotificationService
 
     return unless mailer.respond_to?(email_template)
 
-    recipients ||= NotificationRecipientService.new(pipeline.project).build_pipeline_recipients(
-      pipeline,
-      pipeline.user,
-      action: pipeline.status
+    recipients ||= NotificationRecipientService.notifiable_users(
+      [pipeline.user], :watch,
+      custom_action: :"#{pipeline.status}_pipeline",
+      target: pipeline
     ).map(&:notification_email)
 
     if recipients.any?
@@ -308,16 +313,16 @@ class NotificationService
 
   protected
 
-  def new_resource_email(target, project, method)
-    recipients = NotificationRecipientService.new(project).build_recipients(target, target.author, action: "new")
+  def new_resource_email(target, method)
+    recipients = NotificationRecipientService.build_recipients(target, target.author, action: "new")
 
     recipients.each do |recipient|
       mailer.send(method, recipient.id, target.id).deliver_later
     end
   end
 
-  def new_mentions_in_resource_email(target, project, new_mentioned_users, current_user, method)
-    recipients = NotificationRecipientService.new(project).build_recipients(target, current_user, action: "new")
+  def new_mentions_in_resource_email(target, new_mentioned_users, current_user, method)
+    recipients = NotificationRecipientService.build_recipients(target, current_user, action: "new")
     recipients = recipients & new_mentioned_users
 
     recipients.each do |recipient|
@@ -325,10 +330,10 @@ class NotificationService
     end
   end
 
-  def close_resource_email(target, project, current_user, method, skip_current_user: true)
+  def close_resource_email(target, current_user, method, skip_current_user: true)
     action = method == :merged_merge_request_email ? "merge" : "close"
 
-    recipients = NotificationRecipientService.new(project).build_recipients(
+    recipients = NotificationRecipientService.build_recipients(
       target,
       current_user,
       action: action,
@@ -340,11 +345,11 @@ class NotificationService
     end
   end
 
-  def reassign_resource_email(target, project, current_user, method)
+  def reassign_resource_email(target, current_user, method)
     previous_assignee_id = previous_record(target, 'assignee_id')
     previous_assignee = User.find_by(id: previous_assignee_id) if previous_assignee_id
 
-    recipients = NotificationRecipientService.new(project).build_recipients(
+    recipients = NotificationRecipientService.build_recipients(
       target,
       current_user,
       action: "reassign",
@@ -362,8 +367,14 @@ class NotificationService
     end
   end
 
-  def relabeled_resource_email(target, project, labels, current_user, method)
-    recipients = NotificationRecipientService.new(project).build_relabeled_recipients(target, current_user, labels: labels)
+  def relabeled_resource_email(target, labels, current_user, method)
+    recipients = labels.flat_map { |l| l.subscribers(target.project) }
+    recipients = NotificationRecipientService.notifiable_users(
+      recipients, :subscription,
+      target: target,
+      acting_user: current_user
+    )
+
     label_names = labels.map(&:name)
 
     recipients.each do |recipient|
@@ -371,8 +382,8 @@ class NotificationService
     end
   end
 
-  def reopen_resource_email(target, project, current_user, method, status)
-    recipients = NotificationRecipientService.new(project).build_recipients(target, current_user, action: "reopen")
+  def reopen_resource_email(target, current_user, method, status)
+    recipients = NotificationRecipientService.build_recipients(target, current_user, action: "reopen")
 
     recipients.each do |recipient|
       mailer.send(method, recipient.id, target.id, status, current_user.id).deliver_later
diff --git a/app/services/projects/destroy_service.rb b/app/services/projects/destroy_service.rb
index e2b2660ea71..11ad4838471 100644
--- a/app/services/projects/destroy_service.rb
+++ b/app/services/projects/destroy_service.rb
@@ -9,46 +9,54 @@ module Projects
     def async_execute
       project.update_attribute(:pending_delete, true)
       job_id = ProjectDestroyWorker.perform_async(project.id, current_user.id, params)
-      Rails.logger.info("User #{current_user.id} scheduled destruction of project #{project.path_with_namespace} with job ID #{job_id}")
+      Rails.logger.info("User #{current_user.id} scheduled destruction of project #{project.full_path} with job ID #{job_id}")
     end
 
     def execute
       return false unless can?(current_user, :remove_project, project)
 
-      repo_path = project.path_with_namespace
-      wiki_path = repo_path + '.wiki'
-
       # Flush the cache for both repositories. This has to be done _before_
       # removing the physical repositories as some expiration code depends on
       # Git data (e.g. a list of branch names).
-      flush_caches(project, wiki_path)
+      flush_caches(project)
 
       Projects::UnlinkForkService.new(project, current_user).execute
 
-      Project.transaction do
-        project.team.truncate
-        project.destroy!
-
-        unless remove_legacy_registry_tags
-          raise_error('Failed to remove some tags in project container registry. Please try again or contact administrator.')
-        end
-
-        unless remove_repository(repo_path)
-          raise_error('Failed to remove project repository. Please try again or contact administrator.')
-        end
+      attempt_destroy_transaction(project)
 
-        unless remove_repository(wiki_path)
-          raise_error('Failed to remove wiki repository. Please try again or contact administrator.')
-        end
-      end
-
-      log_info("Project \"#{project.path_with_namespace}\" was removed")
       system_hook_service.execute_hooks_for(project, :destroy)
+      log_info("Project \"#{project.full_path}\" was removed")
+
       true
+    rescue => error
+      attempt_rollback(project, error.message)
+      false
+    rescue Exception => error # rubocop:disable Lint/RescueException
+      # Project.transaction can raise Exception
+      attempt_rollback(project, error.message)
+      raise
     end
 
     private
 
+    def repo_path
+      project.disk_path
+    end
+
+    def wiki_path
+      repo_path + '.wiki'
+    end
+
+    def trash_repositories!
+      unless remove_repository(repo_path)
+        raise_error('Failed to remove project repository. Please try again or contact administrator.')
+      end
+
+      unless remove_repository(wiki_path)
+        raise_error('Failed to remove wiki repository. Please try again or contact administrator.')
+      end
+    end
+
     def remove_repository(path)
       # Skip repository removal. We use this flag when remove user or group
       return true if params[:skip_repo] == true
@@ -70,6 +78,26 @@ module Projects
       end
     end
 
+    def attempt_rollback(project, message)
+      return unless project
+
+      project.update_attributes(delete_error: message, pending_delete: false)
+      log_error("Deletion failed on #{project.full_path} with the following message: #{message}")
+    end
+
+    def attempt_destroy_transaction(project)
+      Project.transaction do
+        unless remove_legacy_registry_tags
+          raise_error('Failed to remove some tags in project container registry. Please try again or contact administrator.')
+        end
+
+        trash_repositories!
+
+        project.team.truncate
+        project.destroy!
+      end
+    end
+
     ##
     # This method makes sure that we correctly remove registry tags
     # for legacy image repository (when repository path equals project path).
@@ -96,10 +124,10 @@ module Projects
       "#{path}+#{project.id}#{DELETED_FLAG}"
     end
 
-    def flush_caches(project, wiki_path)
+    def flush_caches(project)
       project.repository.before_delete
 
-      Repository.new(wiki_path, project).before_delete
+      Repository.new(wiki_path, project, disk_path: repo_path).before_delete
     end
   end
 end
diff --git a/app/services/projects/import_export/export_service.rb b/app/services/projects/import_export/export_service.rb
index 535da706159..fe4e8ea10bf 100644
--- a/app/services/projects/import_export/export_service.rb
+++ b/app/services/projects/import_export/export_service.rb
@@ -2,7 +2,7 @@ module Projects
   module ImportExport
     class ExportService < BaseService
       def execute(_options = {})
-        @shared = Gitlab::ImportExport::Shared.new(relative_path: File.join(project.path_with_namespace, 'work'))
+        @shared = Gitlab::ImportExport::Shared.new(relative_path: File.join(project.disk_path, 'work'))
         save_all
       end
 
diff --git a/app/services/projects/import_service.rb b/app/services/projects/import_service.rb
index eea17e24903..50ec3651515 100644
--- a/app/services/projects/import_service.rb
+++ b/app/services/projects/import_service.rb
@@ -11,7 +11,7 @@ module Projects
 
       success
     rescue => e
-      error("Error importing repository #{project.import_url} into #{project.path_with_namespace} - #{e.message}")
+      error("Error importing repository #{project.import_url} into #{project.full_path} - #{e.message}")
     end
 
     private
@@ -51,7 +51,7 @@ module Projects
     end
 
     def clone_repository
-      gitlab_shell.import_repository(project.repository_storage_path, project.path_with_namespace, project.import_url)
+      gitlab_shell.import_repository(project.repository_storage_path, project.disk_path, project.import_url)
     end
 
     def fetch_repository
diff --git a/app/services/projects/transfer_service.rb b/app/services/projects/transfer_service.rb
index 4bb98e5cb4e..5957f612e84 100644
--- a/app/services/projects/transfer_service.rb
+++ b/app/services/projects/transfer_service.rb
@@ -34,7 +34,7 @@ module Projects
     private
 
     def transfer(project)
-      @old_path = project.path_with_namespace
+      @old_path = project.full_path
       @old_group = project.group
       @new_path = File.join(@new_namespace.try(:full_path) || '', project.path)
       @old_namespace = project.namespace
@@ -61,11 +61,13 @@ module Projects
         project.send_move_instructions(@old_path)
 
         # Move main repository
+        # TODO: check storage type and NOOP when not using Legacy
         unless move_repo_folder(@old_path, @new_path)
           raise TransferError.new('Cannot move project')
         end
 
         # Move wiki repo also if present
+        # TODO: check storage type and NOOP when not using Legacy
         move_repo_folder("#{@old_path}.wiki", "#{@new_path}.wiki")
 
         # Move missing group labels to project
diff --git a/app/services/projects/update_pages_service.rb b/app/services/projects/update_pages_service.rb
index e60b854f916..749a1cc56d8 100644
--- a/app/services/projects/update_pages_service.rb
+++ b/app/services/projects/update_pages_service.rb
@@ -130,7 +130,11 @@ module Projects
     end
 
     def max_size
-      current_application_settings.max_pages_size.megabytes || MAX_SIZE
+      max_pages_size = current_application_settings.max_pages_size.megabytes
+
+      return MAX_SIZE if max_pages_size.zero?
+
+      [max_pages_size, MAX_SIZE].min
     end
 
     def tmp_path
diff --git a/app/services/quick_actions/interpret_service.rb b/app/services/quick_actions/interpret_service.rb
index 6f82159e6c7..c22bf7498bb 100644
--- a/app/services/quick_actions/interpret_service.rb
+++ b/app/services/quick_actions/interpret_service.rb
@@ -4,6 +4,9 @@ module QuickActions
 
     attr_reader :issuable
 
+    SHRUG = '¯\\＿(ツ)＿/¯'.freeze
+    TABLEFLIP = '(╯°□°)╯︵ ┻━┻'.freeze
+
     # Takes a text and interprets the commands that are extracted from it.
     # Returns the content without commands, and hash of changes to be applied to a record.
     def execute(content, issuable)
@@ -14,6 +17,7 @@ module QuickActions
 
       content, commands = extractor.extract_commands(content, context)
       extract_updates(commands, context)
+
       [content, @updates]
     end
 
@@ -423,6 +427,18 @@ module QuickActions
       @updates[:spend_time] = { duration: :reset, user: current_user }
     end
 
+    desc "Append the comment with #{SHRUG}"
+    params '<Comment>'
+    substitution :shrug do |comment|
+      "#{comment} #{SHRUG}"
+    end
+
+    desc "Append the comment with #{TABLEFLIP}"
+    params '<Comment>'
+    substitution :tableflip do |comment|
+      "#{comment} #{TABLEFLIP}"
+    end
+
     # This is a dummy command, so that it appears in the autocomplete commands
     desc 'CC'
     params '@user'
@@ -471,6 +487,24 @@ module QuickActions
       end
     end
 
+    desc 'Mark this issue as a duplicate of another issue'
+    explanation do |duplicate_reference|
+      "Marks this issue as a duplicate of #{duplicate_reference}."
+    end
+    params '#issue'
+    condition do
+      issuable.is_a?(Issue) &&
+        issuable.persisted? &&
+        current_user.can?(:"update_#{issuable.to_ability_name}", issuable)
+    end
+    command :duplicate do |duplicate_param|
+      canonical_issue = extract_references(duplicate_param, :issue).first
+
+      if canonical_issue.present?
+        @updates[:canonical_issue_id] = canonical_issue.id
+      end
+    end
+
     def extract_users(params)
       return [] if params.nil?
 
diff --git a/app/services/system_hooks_service.rb b/app/services/system_hooks_service.rb
index bd58a54592f..cbcd4478af6 100644
--- a/app/services/system_hooks_service.rb
+++ b/app/services/system_hooks_service.rb
@@ -24,7 +24,7 @@ class SystemHooksService
         key: model.key,
         id: model.id
       )
- 
+
       if model.user
         data[:username] = model.user.username
       end
@@ -56,7 +56,7 @@ class SystemHooksService
     when GroupMember
       data.merge!(group_member_data(model))
     end
-    
+
     data
   end
 
@@ -79,7 +79,7 @@ class SystemHooksService
     {
       name: model.name,
       path: model.path,
-      path_with_namespace: model.path_with_namespace,
+      path_with_namespace: model.full_path,
       project_id: model.id,
       owner_name: owner.name,
       owner_email: owner.respond_to?(:email) ? owner.email : "",
@@ -93,7 +93,7 @@ class SystemHooksService
     {
       project_name:                 project.name,
       project_path:                 project.path,
-      project_path_with_namespace:  project.path_with_namespace,
+      project_path_with_namespace:  project.full_path,
       project_id:                   project.id,
       user_username:                model.user.username,
       user_name:                    model.user.name,
diff --git a/app/services/system_note_service.rb b/app/services/system_note_service.rb
index da0f21d449a..2dbee9c246e 100644
--- a/app/services/system_note_service.rb
+++ b/app/services/system_note_service.rb
@@ -552,6 +552,44 @@ module SystemNoteService
     create_note(NoteSummary.new(noteable, project, author, body, action: 'moved'))
   end
 
+  # Called when a Noteable has been marked as a duplicate of another Issue
+  #
+  # noteable        - Noteable object
+  # project         - Project owning noteable
+  # author          - User performing the change
+  # canonical_issue - Issue that this is a duplicate of
+  #
+  # Example Note text:
+  #
+  #   "marked this issue as a duplicate of #1234"
+  #
+  #   "marked this issue as a duplicate of other_project#5678"
+  #
+  # Returns the created Note object
+  def mark_duplicate_issue(noteable, project, author, canonical_issue)
+    body = "marked this issue as a duplicate of #{canonical_issue.to_reference(project)}"
+    create_note(NoteSummary.new(noteable, project, author, body, action: 'duplicate'))
+  end
+
+  # Called when a Noteable has been marked as the canonical Issue of a duplicate
+  #
+  # noteable        - Noteable object
+  # project         - Project owning noteable
+  # author          - User performing the change
+  # duplicate_issue - Issue that was a duplicate of this
+  #
+  # Example Note text:
+  #
+  #   "marked #1234 as a duplicate of this issue"
+  #
+  #   "marked other_project#5678 as a duplicate of this issue"
+  #
+  # Returns the created Note object
+  def mark_canonical_issue_of_duplicate(noteable, project, author, duplicate_issue)
+    body = "marked #{duplicate_issue.to_reference(project)} as a duplicate of this issue"
+    create_note(NoteSummary.new(noteable, project, author, body, action: 'duplicate'))
+  end
+
   private
 
   def notes_for_mentioner(mentioner, noteable, notes)
diff --git a/app/services/todo_service.rb b/app/services/todo_service.rb
index 322c6286365..6ee96d6a0f8 100644
--- a/app/services/todo_service.rb
+++ b/app/services/todo_service.rb
@@ -170,20 +170,22 @@ class TodoService
 
   # When user marks some todos as done
   def mark_todos_as_done(todos, current_user)
-    update_todos_state_by_ids(todos.select(&:id), current_user, :done)
+    update_todos_state(todos, current_user, :done)
   end
 
   def mark_todos_as_done_by_ids(ids, current_user)
-    update_todos_state_by_ids(ids, current_user, :done)
+    todos = todos_by_ids(ids, current_user)
+    mark_todos_as_done(todos, current_user)
   end
 
   # When user marks some todos as pending
   def mark_todos_as_pending(todos, current_user)
-    update_todos_state_by_ids(todos.select(&:id), current_user, :pending)
+    update_todos_state(todos, current_user, :pending)
   end
 
   def mark_todos_as_pending_by_ids(ids, current_user)
-    update_todos_state_by_ids(ids, current_user, :pending)
+    todos = todos_by_ids(ids, current_user)
+    mark_todos_as_pending(todos, current_user)
   end
 
   # When user marks an issue as todo
@@ -198,9 +200,11 @@ class TodoService
 
   private
 
-  def update_todos_state_by_ids(ids, current_user, state)
-    todos = current_user.todos.where(id: ids)
+  def todos_by_ids(ids, current_user)
+    current_user.todos.where(id: Array(ids))
+  end
 
+  def update_todos_state(todos, current_user, state)
     # Only update those that are not really on that state
     todos = todos.where.not(state: state)
     todos_ids = todos.pluck(:id)
diff --git a/app/services/web_hook_service.rb b/app/services/web_hook_service.rb
index a5110a23cad..2825478926a 100644
--- a/app/services/web_hook_service.rb
+++ b/app/services/web_hook_service.rb
@@ -44,7 +44,7 @@ class WebHookService
       http_status: response.code,
       message: response.to_s
     }
-  rescue SocketError, OpenSSL::SSL::SSLError, Errno::ECONNRESET, Errno::ECONNREFUSED, Net::OpenTimeout => e
+  rescue SocketError, OpenSSL::SSL::SSLError, Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Net::OpenTimeout, Net::ReadTimeout => e
     log_execution(
       trigger: hook_name,
       url: hook.url,
@@ -101,7 +101,7 @@ class WebHookService
       request_headers: build_headers(hook_name),
       request_data: request_data,
       response_headers: format_response_headers(response),
-      response_body: response.body,
+      response_body: safe_response_body(response),
       response_status: response.code,
       internal_error_message: error_message
     )
@@ -124,4 +124,10 @@ class WebHookService
   def format_response_headers(response)
     response.headers.each_capitalized.to_h
   end
+
+  def safe_response_body(response)
+    return '' unless response.body
+
+    response.body.encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+  end
 end
diff --git a/app/services/wiki_pages/update_service.rb b/app/services/wiki_pages/update_service.rb
index 8f6a50da838..c628e6781af 100644
--- a/app/services/wiki_pages/update_service.rb
+++ b/app/services/wiki_pages/update_service.rb
@@ -1,7 +1,7 @@
 module WikiPages
   class UpdateService < WikiPages::BaseService
     def execute(page)
-      if page.update(@params[:content], @params[:format], @params[:message])
+      if page.update(@params[:content], format: @params[:format], message: @params[:message], last_commit_sha: @params[:last_commit_sha])
         execute_hooks(page, 'update')
       end