Merge branch 'fe-paginated-environments-api' into fe-paginated-environments-paginationfe-paginated-environments-pagination

* fe-paginated-environments-api: (304 commits)
  added missed commit in rebase
  update Grape routes to work with current version of Grape
  adds changelog
  fixes cursor issue on pipeline pagination
  Use random group name to prevent conflicts
  List all groups/projects for admins on explore pages
  Fix indentation
  More backport
  Fix filtered search user autocomplete for gitlab instances that are hosted on a subdirectory
  Fixed variables_controller_spec.rb test
  Backport of the frontend view, including tests
  Updated the #create action to render the show view in case of a form error
  Improved code styling on the variables_controller_spec
  Added tests for the variables controller #update action
  Added a variable_controller_spec test to test for flash messages on the #create action
  Modified redirection logic in the variables cont.
  Added redirections to the index actions for the variables and triggers controllers
  Added a flash message to the creation of triggers
  Fixed tests, renamed files and methods
  Changed the controller/route name to 'ci/cd' and renamed the corresponding files
  ...

29 files changed, 1468 insertions, 220 deletions

diff --git a/lib/api/api.rb b/lib/api/api.rb
index 6cf6b501021..1950d2791ab 100644
--- a/lib/api/api.rb
+++ b/lib/api/api.rb
@@ -1,7 +1,14 @@
 module API
   class API < Grape::API
     include APIGuard
-    version 'v3', using: :path
+
+    version %w(v3 v4), using: :path
+
+    version 'v3', using: :path do
+      mount ::API::V3::Issues
+      mount ::API::V3::MergeRequests
+      mount ::API::V3::Projects
+    end
 
     before { allow_access_with_scope :api }
 
diff --git a/lib/api/entities.rb b/lib/api/entities.rb
index a07b2a9ca0f..b1ead48caf7 100644
--- a/lib/api/entities.rb
+++ b/lib/api/entities.rb
@@ -575,6 +575,7 @@ module API
       expose :koding_url
       expose :plantuml_enabled
       expose :plantuml_url
+      expose :terminal_max_session_time
     end
 
     class Release < Grape::Entity
diff --git a/lib/api/helpers.rb b/lib/api/helpers.rb
index eb5b947172a..dfab60f7fa5 100644
--- a/lib/api/helpers.rb
+++ b/lib/api/helpers.rb
@@ -304,7 +304,7 @@ module API
         header['X-Sendfile'] = path
         body
       else
-        path
+        file path
       end
     end
 
diff --git a/lib/api/issues.rb b/lib/api/issues.rb
index fe016c1ec0a..90fca20d4fa 100644
--- a/lib/api/issues.rb
+++ b/lib/api/issues.rb
@@ -15,8 +15,6 @@ module API
         labels = args.delete(:labels)
         args[:label_name] = labels if match_all_labels
 
-        args[:search] = "#{Issue.reference_prefix}#{args.delete(:iid)}" if args.key?(:iid)
-
         issues = IssuesFinder.new(current_user, args).execute.inc_notes_with_associations
 
         # TODO: Remove in 9.0  pass `label_name: args.delete(:labels)` to IssuesFinder
@@ -97,7 +95,6 @@ module API
       params do
         optional :state, type: String, values: %w[opened closed all], default: 'all',
                          desc: 'Return opened, closed, or all issues'
-        optional :iid, type: Integer, desc: 'Return the issue having the given `iid`'
         use :issues_params
       end
       get ":id/issues" do
diff --git a/lib/api/merge_requests.rb b/lib/api/merge_requests.rb
index 7ffb38e62da..782147883c8 100644
--- a/lib/api/merge_requests.rb
+++ b/lib/api/merge_requests.rb
@@ -2,8 +2,6 @@ module API
   class MergeRequests < Grape::API
     include PaginationParams
 
-    DEPRECATION_MESSAGE = 'This endpoint is deprecated and will be removed in GitLab 9.0.'.freeze
-
     before { authenticate! }
 
     params do
@@ -46,14 +44,14 @@ module API
                             desc: 'Return merge requests ordered by `created_at` or `updated_at` fields.'
         optional :sort, type: String, values: %w[asc desc], default: 'desc',
                         desc: 'Return merge requests sorted in `asc` or `desc` order.'
-        optional :iid, type: Array[Integer], desc: 'The IID of the merge requests'
+        optional :iids, type: Array[Integer], desc: 'The IID array of merge requests'
         use :pagination
       end
       get ":id/merge_requests" do
         authorize! :read_merge_request, user_project
 
         merge_requests = user_project.merge_requests.inc_notes_with_associations
-        merge_requests = filter_by_iid(merge_requests, params[:iid]) if params[:iid].present?
+        merge_requests = filter_by_iid(merge_requests, params[:iids]) if params[:iids].present?
 
         merge_requests =
           case params[:state]
@@ -104,177 +102,167 @@ module API
         merge_request.destroy
       end
 
-      # Routing "merge_request/:merge_request_id/..." is DEPRECATED and WILL BE REMOVED in version 9.0
-      # Use "merge_requests/:merge_request_id/..." instead.
-      #
       params do
         requires :merge_request_id, type: Integer, desc: 'The ID of a merge request'
       end
-      { ":id/merge_request/:merge_request_id" => :deprecated, ":id/merge_requests/:merge_request_id" => :ok }.each do |path, status|
-        desc 'Get a single merge request' do
-          if status == :deprecated
-            detail DEPRECATION_MESSAGE
-          end
-          success Entities::MergeRequest
-        end
-        get path do
-          merge_request = find_merge_request_with_access(params[:merge_request_id])
+      desc 'Get a single merge request' do
+        success Entities::MergeRequest
+      end
+      get ':id/merge_requests/:merge_request_id' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id])
 
-          present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
-        end
+        present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+      end
 
-        desc 'Get the commits of a merge request' do
-          success Entities::RepoCommit
-        end
-        get "#{path}/commits" do
-          merge_request = find_merge_request_with_access(params[:merge_request_id])
+      desc 'Get the commits of a merge request' do
+        success Entities::RepoCommit
+      end
+      get ':id/merge_requests/:merge_request_id/commits' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id])
 
-          present merge_request.commits, with: Entities::RepoCommit
-        end
+        present merge_request.commits, with: Entities::RepoCommit
+      end
 
-        desc 'Show the merge request changes' do
-          success Entities::MergeRequestChanges
-        end
-        get "#{path}/changes" do
-          merge_request = find_merge_request_with_access(params[:merge_request_id])
+      desc 'Show the merge request changes' do
+        success Entities::MergeRequestChanges
+      end
+      get ':id/merge_requests/:merge_request_id/changes' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id])
 
-          present merge_request, with: Entities::MergeRequestChanges, current_user: current_user
-        end
+        present merge_request, with: Entities::MergeRequestChanges, current_user: current_user
+      end
 
-        desc 'Update a merge request' do
-          success Entities::MergeRequest
-        end
-        params do
-          optional :title, type: String, allow_blank: false, desc: 'The title of the merge request'
-          optional :target_branch, type: String, allow_blank: false, desc: 'The target branch'
-          optional :state_event, type: String, values: %w[close reopen merge],
-                                 desc: 'Status of the merge request'
-          use :optional_params
-          at_least_one_of :title, :target_branch, :description, :assignee_id,
-                          :milestone_id, :labels, :state_event,
-                          :remove_source_branch
-        end
-        put path do
-          merge_request = find_merge_request_with_access(params.delete(:merge_request_id), :update_merge_request)
+      desc 'Update a merge request' do
+        success Entities::MergeRequest
+      end
+      params do
+        optional :title, type: String, allow_blank: false, desc: 'The title of the merge request'
+        optional :target_branch, type: String, allow_blank: false, desc: 'The target branch'
+        optional :state_event, type: String, values: %w[close reopen merge],
+                               desc: 'Status of the merge request'
+        use :optional_params
+        at_least_one_of :title, :target_branch, :description, :assignee_id,
+                        :milestone_id, :labels, :state_event,
+                        :remove_source_branch
+      end
+      put ':id/merge_requests/:merge_request_id' do
+        merge_request = find_merge_request_with_access(params.delete(:merge_request_id), :update_merge_request)
 
-          mr_params = declared_params(include_missing: false)
-          mr_params[:force_remove_source_branch] = mr_params.delete(:remove_source_branch) if mr_params[:remove_source_branch].present?
+        mr_params = declared_params(include_missing: false)
+        mr_params[:force_remove_source_branch] = mr_params.delete(:remove_source_branch) if mr_params[:remove_source_branch].present?
 
-          merge_request = ::MergeRequests::UpdateService.new(user_project, current_user, mr_params).execute(merge_request)
+        merge_request = ::MergeRequests::UpdateService.new(user_project, current_user, mr_params).execute(merge_request)
 
-          if merge_request.valid?
-            present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
-          else
-            handle_merge_request_errors! merge_request.errors
-          end
+        if merge_request.valid?
+          present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+        else
+          handle_merge_request_errors! merge_request.errors
         end
+      end
 
-        desc 'Merge a merge request' do
-          success Entities::MergeRequest
-        end
-        params do
-          optional :merge_commit_message, type: String, desc: 'Custom merge commit message'
-          optional :should_remove_source_branch, type: Boolean,
-                                                 desc: 'When true, the source branch will be deleted if possible'
-          optional :merge_when_build_succeeds, type: Boolean,
-                                               desc: 'When true, this merge request will be merged when the pipeline succeeds'
-          optional :sha, type: String, desc: 'When present, must have the HEAD SHA of the source branch'
-        end
-        put "#{path}/merge" do
-          merge_request = find_project_merge_request(params[:merge_request_id])
+      desc 'Merge a merge request' do
+        success Entities::MergeRequest
+      end
+      params do
+        optional :merge_commit_message, type: String, desc: 'Custom merge commit message'
+        optional :should_remove_source_branch, type: Boolean,
+                                               desc: 'When true, the source branch will be deleted if possible'
+        optional :merge_when_build_succeeds, type: Boolean,
+                                             desc: 'When true, this merge request will be merged when the pipeline succeeds'
+        optional :sha, type: String, desc: 'When present, must have the HEAD SHA of the source branch'
+      end
+      put ':id/merge_requests/:merge_request_id/merge' do
+        merge_request = find_project_merge_request(params[:merge_request_id])
 
-          # Merge request can not be merged
-          # because user dont have permissions to push into target branch
-          unauthorized! unless merge_request.can_be_merged_by?(current_user)
+        # Merge request can not be merged
+        # because user dont have permissions to push into target branch
+        unauthorized! unless merge_request.can_be_merged_by?(current_user)
 
-          not_allowed! unless merge_request.mergeable_state?
+        not_allowed! unless merge_request.mergeable_state?
 
-          render_api_error!('Branch cannot be merged', 406) unless merge_request.mergeable?
+        render_api_error!('Branch cannot be merged', 406) unless merge_request.mergeable?
 
-          if params[:sha] && merge_request.diff_head_sha != params[:sha]
-            render_api_error!("SHA does not match HEAD of source branch: #{merge_request.diff_head_sha}", 409)
-          end
+        if params[:sha] && merge_request.diff_head_sha != params[:sha]
+          render_api_error!("SHA does not match HEAD of source branch: #{merge_request.diff_head_sha}", 409)
+        end
 
-          merge_params = {
-            commit_message: params[:merge_commit_message],
-            should_remove_source_branch: params[:should_remove_source_branch]
-          }
-
-          if params[:merge_when_build_succeeds] && merge_request.head_pipeline && merge_request.head_pipeline.active?
-            ::MergeRequests::MergeWhenPipelineSucceedsService
-              .new(merge_request.target_project, current_user, merge_params)
-              .execute(merge_request)
-          else
-            ::MergeRequests::MergeService
-              .new(merge_request.target_project, current_user, merge_params)
-              .execute(merge_request)
-          end
+        merge_params = {
+          commit_message: params[:merge_commit_message],
+          should_remove_source_branch: params[:should_remove_source_branch]
+        }
 
-          present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+        if params[:merge_when_build_succeeds] && merge_request.head_pipeline && merge_request.head_pipeline.active?
+          ::MergeRequests::MergeWhenPipelineSucceedsService
+            .new(merge_request.target_project, current_user, merge_params)
+            .execute(merge_request)
+        else
+          ::MergeRequests::MergeService
+            .new(merge_request.target_project, current_user, merge_params)
+            .execute(merge_request)
         end
 
-        desc 'Cancel merge if "Merge When Pipeline Succeeds" is enabled' do
-          success Entities::MergeRequest
-        end
-        post "#{path}/cancel_merge_when_build_succeeds" do
-          merge_request = find_project_merge_request(params[:merge_request_id])
+        present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+      end
 
-          unauthorized! unless merge_request.can_cancel_merge_when_build_succeeds?(current_user)
+      desc 'Cancel merge if "Merge When Pipeline Succeeds" is enabled' do
+        success Entities::MergeRequest
+      end
+      post ':id/merge_requests/:merge_request_id/cancel_merge_when_build_succeeds' do
+        merge_request = find_project_merge_request(params[:merge_request_id])
 
-          ::MergeRequest::MergeWhenPipelineSucceedsService
-            .new(merge_request.target_project, current_user)
-            .cancel(merge_request)
-        end
+        unauthorized! unless merge_request.can_cancel_merge_when_build_succeeds?(current_user)
 
-        desc 'Get the comments of a merge request' do
-          detail 'Duplicate. DEPRECATED and WILL BE REMOVED in 9.0'
-          success Entities::MRNote
-        end
-        params do
-          use :pagination
-        end
-        get "#{path}/comments" do
-          merge_request = find_merge_request_with_access(params[:merge_request_id])
-          present paginate(merge_request.notes.fresh), with: Entities::MRNote
-        end
+        ::MergeRequest::MergeWhenPipelineSucceedsService
+          .new(merge_request.target_project, current_user)
+          .cancel(merge_request)
+      end
 
-        desc 'Post a comment to a merge request' do
-          detail 'Duplicate. DEPRECATED and WILL BE REMOVED in 9.0'
-          success Entities::MRNote
-        end
-        params do
-          requires :note, type: String, desc: 'The text of the comment'
-        end
-        post "#{path}/comments" do
-          merge_request = find_merge_request_with_access(params[:merge_request_id], :create_note)
+      desc 'Get the comments of a merge request' do
+        success Entities::MRNote
+      end
+      params do
+        use :pagination
+      end
+      get ':id/merge_requests/:merge_request_id/comments' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id])
+        present paginate(merge_request.notes.fresh), with: Entities::MRNote
+      end
 
-          opts = {
-            note: params[:note],
-            noteable_type: 'MergeRequest',
-            noteable_id: merge_request.id
-          }
+      desc 'Post a comment to a merge request' do
+        success Entities::MRNote
+      end
+      params do
+        requires :note, type: String, desc: 'The text of the comment'
+      end
+      post ':id/merge_requests/:merge_request_id/comments' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id], :create_note)
 
-          note = ::Notes::CreateService.new(user_project, current_user, opts).execute
+        opts = {
+          note: params[:note],
+          noteable_type: 'MergeRequest',
+          noteable_id: merge_request.id
+        }
 
-          if note.save
-            present note, with: Entities::MRNote
-          else
-            render_api_error!("Failed to save note #{note.errors.messages}", 400)
-          end
-        end
+        note = ::Notes::CreateService.new(user_project, current_user, opts).execute
 
-        desc 'List issues that will be closed on merge' do
-          success Entities::MRNote
-        end
-        params do
-          use :pagination
-        end
-        get "#{path}/closes_issues" do
-          merge_request = find_merge_request_with_access(params[:merge_request_id])
-          issues = ::Kaminari.paginate_array(merge_request.closes_issues(current_user))
-          present paginate(issues), with: issue_entity(user_project), current_user: current_user
+        if note.save
+          present note, with: Entities::MRNote
+        else
+          render_api_error!("Failed to save note #{note.errors.messages}", 400)
         end
       end
+
+      desc 'List issues that will be closed on merge' do
+        success Entities::MRNote
+      end
+      params do
+        use :pagination
+      end
+      get ':id/merge_requests/:merge_request_id/closes_issues' do
+        merge_request = find_merge_request_with_access(params[:merge_request_id])
+        issues = ::Kaminari.paginate_array(merge_request.closes_issues(current_user))
+        present paginate(issues), with: issue_entity(user_project), current_user: current_user
+      end
     end
   end
 end
diff --git a/lib/api/projects.rb b/lib/api/projects.rb
index 941f47114a4..92a70faf1c2 100644
--- a/lib/api/projects.rb
+++ b/lib/api/projects.rb
@@ -151,22 +151,6 @@ module API
         present_projects Project.all, with: Entities::ProjectWithAccess, statistics: params[:statistics]
       end
 
-      desc 'Search for projects the current user has access to' do
-        success Entities::Project
-      end
-      params do
-        requires :query, type: String, desc: 'The project name to be searched'
-        use :sort_params
-        use :pagination
-      end
-      get "/search/:query", requirements: { query: /[^\/]+/ } do
-        search_service = Search::GlobalService.new(current_user, search: params[:query]).execute
-        projects = search_service.objects('projects', params[:page])
-        projects = projects.reorder(params[:order_by] => params[:sort])
-
-        present paginate(projects), with: Entities::Project
-      end
-
       desc 'Create new project' do
         success Entities::Project
       end
diff --git a/lib/api/settings.rb b/lib/api/settings.rb
index c5eff16a5de..747ceb4e3e0 100644
--- a/lib/api/settings.rb
+++ b/lib/api/settings.rb
@@ -57,6 +57,7 @@ module API
         requires :shared_runners_text, type: String, desc: 'Shared runners text '
       end
       optional :max_artifacts_size, type: Integer, desc: "Set the maximum file size each build's artifacts can have"
+      optional :max_pages_size, type: Integer, desc: 'Maximum size of pages in MB'
       optional :container_registry_token_expire_delay, type: Integer, desc: 'Authorization token duration (minutes)'
       optional :metrics_enabled, type: Boolean, desc: 'Enable the InfluxDB metrics'
       given metrics_enabled: ->(val) { val } do
@@ -107,6 +108,7 @@ module API
         requires :housekeeping_full_repack_period, type: Integer, desc: "Number of Git pushes after which a full 'git repack' is run."
         requires :housekeeping_gc_period, type: Integer, desc: "Number of Git pushes after which 'git gc' is run."
       end
+      optional :terminal_max_session_time, type: Integer, desc: 'Maximum time for web terminal websocket connection (in seconds). Set to 0 for unlimited time.'
       at_least_one_of :default_branch_protection, :default_project_visibility, :default_snippet_visibility,
                       :default_group_visibility, :restricted_visibility_levels, :import_sources,
                       :enabled_git_access_protocol, :gravatar_enabled, :default_projects_limit,
@@ -115,12 +117,12 @@ module API
                       :send_user_confirmation_email, :domain_whitelist, :domain_blacklist_enabled,
                       :after_sign_up_text, :signin_enabled, :require_two_factor_authentication,
                       :home_page_url, :after_sign_out_path, :sign_in_text, :help_page_text,
-                      :shared_runners_enabled, :max_artifacts_size, :container_registry_token_expire_delay,
+                      :shared_runners_enabled, :max_artifacts_size, :max_pages_size, :container_registry_token_expire_delay,
                       :metrics_enabled, :sidekiq_throttling_enabled, :recaptcha_enabled,
                       :akismet_enabled, :admin_notification_email, :sentry_enabled,
                       :repository_storage, :repository_checks_enabled, :koding_enabled, :plantuml_enabled,
                       :version_check_enabled, :email_author_in_body, :html_emails_enabled,
-                      :housekeeping_enabled
+                      :housekeeping_enabled, :terminal_max_session_time
     end
     put "application/settings" do
       if current_settings.update_attributes(declared_params(include_missing: false))
diff --git a/lib/api/v3/issues.rb b/lib/api/v3/issues.rb
new file mode 100644
index 00000000000..be3ecc29449
--- /dev/null
+++ b/lib/api/v3/issues.rb
@@ -0,0 +1,231 @@
+module API
+  module V3
+    class Issues < Grape::API
+      include PaginationParams
+
+      before { authenticate! }
+
+      helpers do
+        def find_issues(args = {})
+          args = params.merge(args)
+
+          args.delete(:id)
+          args[:milestone_title] = args.delete(:milestone)
+
+          match_all_labels = args.delete(:match_all_labels)
+          labels = args.delete(:labels)
+          args[:label_name] = labels if match_all_labels
+
+          args[:search] = "#{Issue.reference_prefix}#{args.delete(:iid)}" if args.key?(:iid)
+
+          issues = IssuesFinder.new(current_user, args).execute.inc_notes_with_associations
+
+          if !match_all_labels && labels.present?
+            issues = issues.includes(:labels).where('labels.title' => labels.split(','))
+          end
+
+          issues.reorder(args[:order_by] => args[:sort])
+        end
+
+        params :issues_params do
+          optional :labels, type: String, desc: 'Comma-separated list of label names'
+          optional :milestone, type: String, desc: 'Milestone title'
+          optional :order_by, type: String, values: %w[created_at updated_at], default: 'created_at',
+                              desc: 'Return issues ordered by `created_at` or `updated_at` fields.'
+          optional :sort, type: String, values: %w[asc desc], default: 'desc',
+                          desc: 'Return issues sorted in `asc` or `desc` order.'
+          optional :milestone, type: String, desc: 'Return issues for a specific milestone'
+          use :pagination
+        end
+
+        params :issue_params do
+          optional :description, type: String, desc: 'The description of an issue'
+          optional :assignee_id, type: Integer, desc: 'The ID of a user to assign issue'
+          optional :milestone_id, type: Integer, desc: 'The ID of a milestone to assign issue'
+          optional :labels, type: String, desc: 'Comma-separated list of label names'
+          optional :due_date, type: String, desc: 'Date time string in the format YEAR-MONTH-DAY'
+          optional :confidential, type: Boolean, desc: 'Boolean parameter if the issue should be confidential'
+        end
+      end
+
+      resource :issues do
+        desc "Get currently authenticated user's issues" do
+          success Entities::Issue
+        end
+        params do
+          optional :state, type: String, values: %w[opened closed all], default: 'all',
+                           desc: 'Return opened, closed, or all issues'
+          use :issues_params
+        end
+        get do
+          issues = find_issues(scope: 'authored')
+
+          present paginate(issues), with: Entities::Issue, current_user: current_user
+        end
+      end
+
+      params do
+        requires :id, type: String, desc: 'The ID of a group'
+      end
+      resource :groups do
+        desc 'Get a list of group issues' do
+          success Entities::Issue
+        end
+        params do
+          optional :state, type: String, values: %w[opened closed all], default: 'opened',
+                           desc: 'Return opened, closed, or all issues'
+          use :issues_params
+        end
+        get ":id/issues" do
+          group = find_group!(params[:id])
+
+          issues = find_issues(group_id: group.id, state: params[:state] || 'opened', match_all_labels: true)
+
+          present paginate(issues), with: Entities::Issue, current_user: current_user
+        end
+      end
+
+      params do
+        requires :id, type: String, desc: 'The ID of a project'
+      end
+      resource :projects do
+        include TimeTrackingEndpoints
+
+        desc 'Get a list of project issues' do
+          detail 'iid filter is deprecated have been removed on V4'
+          success Entities::Issue
+        end
+        params do
+          optional :state, type: String, values: %w[opened closed all], default: 'all',
+                           desc: 'Return opened, closed, or all issues'
+          optional :iid, type: Integer, desc: 'Return the issue having the given `iid`'
+          use :issues_params
+        end
+        get ":id/issues" do
+          project = find_project(params[:id])
+
+          issues = find_issues(project_id: project.id)
+
+          present paginate(issues), with: Entities::Issue, current_user: current_user, project: user_project
+        end
+
+        desc 'Get a single project issue' do
+          success Entities::Issue
+        end
+        params do
+          requires :issue_id, type: Integer, desc: 'The ID of a project issue'
+        end
+        get ":id/issues/:issue_id" do
+          issue = find_project_issue(params[:issue_id])
+          present issue, with: Entities::Issue, current_user: current_user, project: user_project
+        end
+
+        desc 'Create a new project issue' do
+          success Entities::Issue
+        end
+        params do
+          requires :title, type: String, desc: 'The title of an issue'
+          optional :created_at, type: DateTime,
+                                desc: 'Date time when the issue was created. Available only for admins and project owners.'
+          optional :merge_request_for_resolving_discussions, type: Integer,
+                                                             desc: 'The IID of a merge request for which to resolve discussions'
+          use :issue_params
+        end
+        post ':id/issues' do
+          # Setting created_at time only allowed for admins and project owners
+          unless current_user.admin? || user_project.owner == current_user
+            params.delete(:created_at)
+          end
+
+          issue_params = declared_params(include_missing: false)
+
+          if merge_request_iid = params[:merge_request_for_resolving_discussions]
+            issue_params[:merge_request_for_resolving_discussions] = MergeRequestsFinder.new(current_user, project_id: user_project.id).
+              execute.
+              find_by(iid: merge_request_iid)
+          end
+
+          issue = ::Issues::CreateService.new(user_project,
+                                              current_user,
+                                              issue_params.merge(request: request, api: true)).execute
+          if issue.spam?
+            render_api_error!({ error: 'Spam detected' }, 400)
+          end
+
+          if issue.valid?
+            present issue, with: Entities::Issue, current_user: current_user, project: user_project
+          else
+            render_validation_error!(issue)
+          end
+        end
+
+        desc 'Update an existing issue' do
+          success Entities::Issue
+        end
+        params do
+          requires :issue_id, type: Integer, desc: 'The ID of a project issue'
+          optional :title, type: String, desc: 'The title of an issue'
+          optional :updated_at, type: DateTime,
+                                desc: 'Date time when the issue was updated. Available only for admins and project owners.'
+          optional :state_event, type: String, values: %w[reopen close], desc: 'State of the issue'
+          use :issue_params
+          at_least_one_of :title, :description, :assignee_id, :milestone_id,
+                          :labels, :created_at, :due_date, :confidential, :state_event
+        end
+        put ':id/issues/:issue_id' do
+          issue = user_project.issues.find(params.delete(:issue_id))
+          authorize! :update_issue, issue
+
+          # Setting created_at time only allowed for admins and project owners
+          unless current_user.admin? || user_project.owner == current_user
+            params.delete(:updated_at)
+          end
+
+          issue = ::Issues::UpdateService.new(user_project,
+                                              current_user,
+                                              declared_params(include_missing: false)).execute(issue)
+
+          if issue.valid?
+            present issue, with: Entities::Issue, current_user: current_user, project: user_project
+          else
+            render_validation_error!(issue)
+          end
+        end
+
+        desc 'Move an existing issue' do
+          success Entities::Issue
+        end
+        params do
+          requires :issue_id, type: Integer, desc: 'The ID of a project issue'
+          requires :to_project_id, type: Integer, desc: 'The ID of the new project'
+        end
+        post ':id/issues/:issue_id/move' do
+          issue = user_project.issues.find_by(id: params[:issue_id])
+          not_found!('Issue') unless issue
+
+          new_project = Project.find_by(id: params[:to_project_id])
+          not_found!('Project') unless new_project
+
+          begin
+            issue = ::Issues::MoveService.new(user_project, current_user).execute(issue, new_project)
+            present issue, with: Entities::Issue, current_user: current_user, project: user_project
+          rescue ::Issues::MoveService::MoveError => error
+            render_api_error!(error.message, 400)
+          end
+        end
+
+        desc 'Delete a project issue'
+        params do
+          requires :issue_id, type: Integer, desc: 'The ID of a project issue'
+        end
+        delete ":id/issues/:issue_id" do
+          issue = user_project.issues.find_by(id: params[:issue_id])
+          not_found!('Issue') unless issue
+
+          authorize!(:destroy_issue, issue)
+          issue.destroy
+        end
+      end
+    end
+  end
+end
diff --git a/lib/api/v3/merge_requests.rb b/lib/api/v3/merge_requests.rb
new file mode 100644
index 00000000000..1af70cf58cc
--- /dev/null
+++ b/lib/api/v3/merge_requests.rb
@@ -0,0 +1,280 @@
+module API
+  module V3
+    class MergeRequests < Grape::API
+      include PaginationParams
+
+      DEPRECATION_MESSAGE = 'This endpoint is deprecated and has been removed on V4'.freeze
+
+      before { authenticate! }
+
+      params do
+        requires :id, type: String, desc: 'The ID of a project'
+      end
+      resource :projects do
+        include TimeTrackingEndpoints
+
+        helpers do
+          def handle_merge_request_errors!(errors)
+            if errors[:project_access].any?
+              error!(errors[:project_access], 422)
+            elsif errors[:branch_conflict].any?
+              error!(errors[:branch_conflict], 422)
+            elsif errors[:validate_fork].any?
+              error!(errors[:validate_fork], 422)
+            elsif errors[:validate_branches].any?
+              conflict!(errors[:validate_branches])
+            end
+
+            render_api_error!(errors, 400)
+          end
+
+          params :optional_params do
+            optional :description, type: String, desc: 'The description of the merge request'
+            optional :assignee_id, type: Integer, desc: 'The ID of a user to assign the merge request'
+            optional :milestone_id, type: Integer, desc: 'The ID of a milestone to assign the merge request'
+            optional :labels, type: String, desc: 'Comma-separated list of label names'
+            optional :remove_source_branch, type: Boolean, desc: 'Remove source branch when merging'
+          end
+        end
+
+        desc 'List merge requests' do
+          detail 'iid filter is deprecated have been removed on V4'
+          success Entities::MergeRequest
+        end
+        params do
+          optional :state, type: String, values: %w[opened closed merged all], default: 'all',
+                           desc: 'Return opened, closed, merged, or all merge requests'
+          optional :order_by, type: String, values: %w[created_at updated_at], default: 'created_at',
+                              desc: 'Return merge requests ordered by `created_at` or `updated_at` fields.'
+          optional :sort, type: String, values: %w[asc desc], default: 'desc',
+                          desc: 'Return merge requests sorted in `asc` or `desc` order.'
+          optional :iid, type: Array[Integer], desc: 'The IID of the merge requests'
+          use :pagination
+        end
+        get ":id/merge_requests" do
+          authorize! :read_merge_request, user_project
+
+          merge_requests = user_project.merge_requests.inc_notes_with_associations
+          merge_requests = filter_by_iid(merge_requests, params[:iid]) if params[:iid].present?
+
+          merge_requests =
+            case params[:state]
+            when 'opened' then merge_requests.opened
+            when 'closed' then merge_requests.closed
+            when 'merged' then merge_requests.merged
+            else merge_requests
+            end
+
+          merge_requests = merge_requests.reorder(params[:order_by] => params[:sort])
+          present paginate(merge_requests), with: Entities::MergeRequest, current_user: current_user, project: user_project
+        end
+
+        desc 'Create a merge request' do
+          success Entities::MergeRequest
+        end
+        params do
+          requires :title, type: String, desc: 'The title of the merge request'
+          requires :source_branch, type: String, desc: 'The source branch'
+          requires :target_branch, type: String, desc: 'The target branch'
+          optional :target_project_id, type: Integer,
+                                       desc: 'The target project of the merge request defaults to the :id of the project'
+          use :optional_params
+        end
+        post ":id/merge_requests" do
+          authorize! :create_merge_request, user_project
+
+          mr_params = declared_params(include_missing: false)
+          mr_params[:force_remove_source_branch] = mr_params.delete(:remove_source_branch) if mr_params[:remove_source_branch].present?
+
+          merge_request = ::MergeRequests::CreateService.new(user_project, current_user, mr_params).execute
+
+          if merge_request.valid?
+            present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+          else
+            handle_merge_request_errors! merge_request.errors
+          end
+        end
+
+        desc 'Delete a merge request'
+        params do
+          requires :merge_request_id, type: Integer, desc: 'The ID of a merge request'
+        end
+        delete ":id/merge_requests/:merge_request_id" do
+          merge_request = find_project_merge_request(params[:merge_request_id])
+
+          authorize!(:destroy_merge_request, merge_request)
+          merge_request.destroy
+        end
+
+        params do
+          requires :merge_request_id, type: Integer, desc: 'The ID of a merge request'
+        end
+        { ":id/merge_request/:merge_request_id" => :deprecated, ":id/merge_requests/:merge_request_id" => :ok }.each do |path, status|
+          desc 'Get a single merge request' do
+            if status == :deprecated
+              detail DEPRECATION_MESSAGE
+            end
+            success Entities::MergeRequest
+          end
+          get path do
+            merge_request = find_merge_request_with_access(params[:merge_request_id])
+
+            present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+          end
+
+          desc 'Get the commits of a merge request' do
+            success Entities::RepoCommit
+          end
+          get "#{path}/commits" do
+            merge_request = find_merge_request_with_access(params[:merge_request_id])
+
+            present merge_request.commits, with: Entities::RepoCommit
+          end
+
+          desc 'Show the merge request changes' do
+            success Entities::MergeRequestChanges
+          end
+          get "#{path}/changes" do
+            merge_request = find_merge_request_with_access(params[:merge_request_id])
+
+            present merge_request, with: Entities::MergeRequestChanges, current_user: current_user
+          end
+
+          desc 'Update a merge request' do
+            success Entities::MergeRequest
+          end
+          params do
+            optional :title, type: String, allow_blank: false, desc: 'The title of the merge request'
+            optional :target_branch, type: String, allow_blank: false, desc: 'The target branch'
+            optional :state_event, type: String, values: %w[close reopen merge],
+                                   desc: 'Status of the merge request'
+            use :optional_params
+            at_least_one_of :title, :target_branch, :description, :assignee_id,
+                            :milestone_id, :labels, :state_event,
+                            :remove_source_branch
+          end
+          put path do
+            merge_request = find_merge_request_with_access(params.delete(:merge_request_id), :update_merge_request)
+
+            mr_params = declared_params(include_missing: false)
+            mr_params[:force_remove_source_branch] = mr_params.delete(:remove_source_branch) if mr_params[:remove_source_branch].present?
+
+            merge_request = ::MergeRequests::UpdateService.new(user_project, current_user, mr_params).execute(merge_request)
+
+            if merge_request.valid?
+              present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+            else
+              handle_merge_request_errors! merge_request.errors
+            end
+          end
+
+          desc 'Merge a merge request' do
+            success Entities::MergeRequest
+          end
+          params do
+            optional :merge_commit_message, type: String, desc: 'Custom merge commit message'
+            optional :should_remove_source_branch, type: Boolean,
+                                                   desc: 'When true, the source branch will be deleted if possible'
+            optional :merge_when_build_succeeds, type: Boolean,
+                                                 desc: 'When true, this merge request will be merged when the pipeline succeeds'
+            optional :sha, type: String, desc: 'When present, must have the HEAD SHA of the source branch'
+          end
+          put "#{path}/merge" do
+            merge_request = find_project_merge_request(params[:merge_request_id])
+
+            # Merge request can not be merged
+            # because user dont have permissions to push into target branch
+            unauthorized! unless merge_request.can_be_merged_by?(current_user)
+
+            not_allowed! unless merge_request.mergeable_state?
+
+            render_api_error!('Branch cannot be merged', 406) unless merge_request.mergeable?
+
+            if params[:sha] && merge_request.diff_head_sha != params[:sha]
+              render_api_error!("SHA does not match HEAD of source branch: #{merge_request.diff_head_sha}", 409)
+            end
+
+            merge_params = {
+              commit_message: params[:merge_commit_message],
+              should_remove_source_branch: params[:should_remove_source_branch]
+            }
+
+            if params[:merge_when_build_succeeds] && merge_request.head_pipeline && merge_request.head_pipeline.active?
+              ::MergeRequests::MergeWhenPipelineSucceedsService
+                .new(merge_request.target_project, current_user, merge_params)
+                .execute(merge_request)
+            else
+              ::MergeRequests::MergeService
+                .new(merge_request.target_project, current_user, merge_params)
+                .execute(merge_request)
+            end
+
+            present merge_request, with: Entities::MergeRequest, current_user: current_user, project: user_project
+          end
+
+          desc 'Cancel merge if "Merge When Pipeline Succeeds" is enabled' do
+            success Entities::MergeRequest
+          end
+          post "#{path}/cancel_merge_when_build_succeeds" do
+            merge_request = find_project_merge_request(params[:merge_request_id])
+
+            unauthorized! unless merge_request.can_cancel_merge_when_build_succeeds?(current_user)
+
+            ::MergeRequest::MergeWhenPipelineSucceedsService
+              .new(merge_request.target_project, current_user)
+              .cancel(merge_request)
+          end
+
+          desc 'Get the comments of a merge request' do
+            detail 'Duplicate. DEPRECATED and HAS BEEN REMOVED in V4'
+            success Entities::MRNote
+          end
+          params do
+            use :pagination
+          end
+          get "#{path}/comments" do
+            merge_request = find_merge_request_with_access(params[:merge_request_id])
+            present paginate(merge_request.notes.fresh), with: Entities::MRNote
+          end
+
+          desc 'Post a comment to a merge request' do
+            detail 'Duplicate. DEPRECATED and HAS BEEN REMOVED in V4'
+            success Entities::MRNote
+          end
+          params do
+            requires :note, type: String, desc: 'The text of the comment'
+          end
+          post "#{path}/comments" do
+            merge_request = find_merge_request_with_access(params[:merge_request_id], :create_note)
+
+            opts = {
+              note: params[:note],
+              noteable_type: 'MergeRequest',
+              noteable_id: merge_request.id
+            }
+
+            note = ::Notes::CreateService.new(user_project, current_user, opts).execute
+
+            if note.save
+              present note, with: Entities::MRNote
+            else
+              render_api_error!("Failed to save note #{note.errors.messages}", 400)
+            end
+          end
+
+          desc 'List issues that will be closed on merge' do
+            success Entities::MRNote
+          end
+          params do
+            use :pagination
+          end
+          get "#{path}/closes_issues" do
+            merge_request = find_merge_request_with_access(params[:merge_request_id])
+            issues = ::Kaminari.paginate_array(merge_request.closes_issues(current_user))
+            present paginate(issues), with: issue_entity(user_project), current_user: current_user
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/api/v3/projects.rb b/lib/api/v3/projects.rb
new file mode 100644
index 00000000000..bac7d485a22
--- /dev/null
+++ b/lib/api/v3/projects.rb
@@ -0,0 +1,458 @@
+module API
+  module V3
+    class Projects < Grape::API
+      include PaginationParams
+
+      before { authenticate_non_get! }
+
+      helpers do
+        params :optional_params do
+          optional :description, type: String, desc: 'The description of the project'
+          optional :issues_enabled, type: Boolean, desc: 'Flag indication if the issue tracker is enabled'
+          optional :merge_requests_enabled, type: Boolean, desc: 'Flag indication if merge requests are enabled'
+          optional :wiki_enabled, type: Boolean, desc: 'Flag indication if the wiki is enabled'
+          optional :builds_enabled, type: Boolean, desc: 'Flag indication if builds are enabled'
+          optional :snippets_enabled, type: Boolean, desc: 'Flag indication if snippets are enabled'
+          optional :shared_runners_enabled, type: Boolean, desc: 'Flag indication if shared runners are enabled for that project'
+          optional :container_registry_enabled, type: Boolean, desc: 'Flag indication if the container registry is enabled for that project'
+          optional :lfs_enabled, type: Boolean, desc: 'Flag indication if Git LFS is enabled for that project'
+          optional :public, type: Boolean, desc: 'Create a public project. The same as visibility_level = 20.'
+          optional :visibility_level, type: Integer, values: [
+            Gitlab::VisibilityLevel::PRIVATE,
+            Gitlab::VisibilityLevel::INTERNAL,
+            Gitlab::VisibilityLevel::PUBLIC ], desc: 'Create a public project. The same as visibility_level = 20.'
+          optional :public_builds, type: Boolean, desc: 'Perform public builds'
+          optional :request_access_enabled, type: Boolean, desc: 'Allow users to request member access'
+          optional :only_allow_merge_if_build_succeeds, type: Boolean, desc: 'Only allow to merge if builds succeed'
+          optional :only_allow_merge_if_all_discussions_are_resolved, type: Boolean, desc: 'Only allow to merge if all discussions are resolved'
+        end
+
+        def map_public_to_visibility_level(attrs)
+          publik = attrs.delete(:public)
+          if !publik.nil? && !attrs[:visibility_level].present?
+            # Since setting the public attribute to private could mean either
+            # private or internal, use the more conservative option, private.
+            attrs[:visibility_level] = (publik == true) ? Gitlab::VisibilityLevel::PUBLIC : Gitlab::VisibilityLevel::PRIVATE
+          end
+          attrs
+        end
+      end
+
+      resource :projects do
+        helpers do
+          params :collection_params do
+            use :sort_params
+            use :filter_params
+            use :pagination
+
+            optional :simple, type: Boolean, default: false,
+                              desc: 'Return only the ID, URL, name, and path of each project'
+          end
+
+          params :sort_params do
+            optional :order_by, type: String, values: %w[id name path created_at updated_at last_activity_at],
+                                default: 'created_at', desc: 'Return projects ordered by field'
+            optional :sort, type: String, values: %w[asc desc], default: 'desc',
+                            desc: 'Return projects sorted in ascending and descending order'
+          end
+
+          params :filter_params do
+            optional :archived, type: Boolean, default: false, desc: 'Limit by archived status'
+            optional :visibility, type: String, values: %w[public internal private],
+                                  desc: 'Limit by visibility'
+            optional :search, type: String, desc: 'Return list of authorized projects matching the search criteria'
+          end
+
+          params :statistics_params do
+            optional :statistics, type: Boolean, default: false, desc: 'Include project statistics'
+          end
+
+          params :create_params do
+            optional :namespace_id, type: Integer, desc: 'Namespace ID for the new project. Default to the user namespace.'
+            optional :import_url, type: String, desc: 'URL from which the project is imported'
+          end
+
+          def present_projects(projects, options = {})
+            options = options.reverse_merge(
+              with: Entities::Project,
+              current_user: current_user,
+              simple: params[:simple],
+            )
+
+            projects = filter_projects(projects)
+            projects = projects.with_statistics if options[:statistics]
+            options[:with] = Entities::BasicProjectDetails if options[:simple]
+
+            present paginate(projects), options
+          end
+        end
+
+        desc 'Get a list of visible projects for authenticated user' do
+          success Entities::BasicProjectDetails
+        end
+        params do
+          use :collection_params
+        end
+        get '/visible' do
+          entity = current_user ? Entities::ProjectWithAccess : Entities::BasicProjectDetails
+          present_projects ProjectsFinder.new.execute(current_user), with: entity
+        end
+
+        desc 'Get a projects list for authenticated user' do
+          success Entities::BasicProjectDetails
+        end
+        params do
+          use :collection_params
+        end
+        get do
+          authenticate!
+
+          present_projects current_user.authorized_projects,
+            with: Entities::ProjectWithAccess
+        end
+
+        desc 'Get an owned projects list for authenticated user' do
+          success Entities::BasicProjectDetails
+        end
+        params do
+          use :collection_params
+          use :statistics_params
+        end
+        get '/owned' do
+          authenticate!
+
+          present_projects current_user.owned_projects,
+            with: Entities::ProjectWithAccess,
+            statistics: params[:statistics]
+        end
+
+        desc 'Gets starred project for the authenticated user' do
+          success Entities::BasicProjectDetails
+        end
+        params do
+          use :collection_params
+        end
+        get '/starred' do
+          authenticate!
+
+          present_projects current_user.viewable_starred_projects
+        end
+
+        desc 'Get all projects for admin user' do
+          success Entities::BasicProjectDetails
+        end
+        params do
+          use :collection_params
+          use :statistics_params
+        end
+        get '/all' do
+          authenticated_as_admin!
+
+          present_projects Project.all, with: Entities::ProjectWithAccess, statistics: params[:statistics]
+        end
+
+        desc 'Search for projects the current user has access to' do
+          success Entities::Project
+        end
+        params do
+          requires :query, type: String, desc: 'The project name to be searched'
+          use :sort_params
+          use :pagination
+        end
+        get "/search/:query", requirements: { query: /[^\/]+/ } do
+          search_service = Search::GlobalService.new(current_user, search: params[:query]).execute
+          projects = search_service.objects('projects', params[:page])
+          projects = projects.reorder(params[:order_by] => params[:sort])
+
+          present paginate(projects), with: Entities::Project
+        end
+
+        desc 'Create new project' do
+          success Entities::Project
+        end
+        params do
+          requires :name, type: String, desc: 'The name of the project'
+          optional :path, type: String, desc: 'The path of the repository'
+          use :optional_params
+          use :create_params
+        end
+        post do
+          attrs = map_public_to_visibility_level(declared_params(include_missing: false))
+          project = ::Projects::CreateService.new(current_user, attrs).execute
+
+          if project.saved?
+            present project, with: Entities::Project,
+                             user_can_admin_project: can?(current_user, :admin_project, project)
+          else
+            if project.errors[:limit_reached].present?
+              error!(project.errors[:limit_reached], 403)
+            end
+            render_validation_error!(project)
+          end
+        end
+
+        desc 'Create new project for a specified user. Only available to admin users.' do
+          success Entities::Project
+        end
+        params do
+          requires :name, type: String, desc: 'The name of the project'
+          requires :user_id, type: Integer, desc: 'The ID of a user'
+          optional :default_branch, type: String, desc: 'The default branch of the project'
+          use :optional_params
+          use :create_params
+        end
+        post "user/:user_id" do
+          authenticated_as_admin!
+          user = User.find_by(id: params.delete(:user_id))
+          not_found!('User') unless user
+
+          attrs = map_public_to_visibility_level(declared_params(include_missing: false))
+          project = ::Projects::CreateService.new(user, attrs).execute
+
+          if project.saved?
+            present project, with: Entities::Project,
+                             user_can_admin_project: can?(current_user, :admin_project, project)
+          else
+            render_validation_error!(project)
+          end
+        end
+      end
+
+      params do
+        requires :id, type: String, desc: 'The ID of a project'
+      end
+      resource :projects, requirements: { id: /[^\/]+/ } do
+        desc 'Get a single project' do
+          success Entities::ProjectWithAccess
+        end
+        get ":id" do
+          entity = current_user ? Entities::ProjectWithAccess : Entities::BasicProjectDetails
+          present user_project, with: entity, current_user: current_user,
+                                user_can_admin_project: can?(current_user, :admin_project, user_project)
+        end
+
+        desc 'Get events for a single project' do
+          success Entities::Event
+        end
+        params do
+          use :pagination
+        end
+        get ":id/events" do
+          present paginate(user_project.events.recent), with: Entities::Event
+        end
+
+        desc 'Fork new project for the current user or provided namespace.' do
+          success Entities::Project
+        end
+        params do
+          optional :namespace, type: String, desc: 'The ID or name of the namespace that the project will be forked into'
+        end
+        post 'fork/:id' do
+          fork_params = declared_params(include_missing: false)
+          namespace_id = fork_params[:namespace]
+
+          if namespace_id.present?
+            fork_params[:namespace] = if namespace_id =~ /^\d+$/
+                                        Namespace.find_by(id: namespace_id)
+                                      else
+                                        Namespace.find_by_path_or_name(namespace_id)
+                                      end
+
+            unless fork_params[:namespace] && can?(current_user, :create_projects, fork_params[:namespace])
+              not_found!('Target Namespace')
+            end
+          end
+
+          forked_project = ::Projects::ForkService.new(user_project, current_user, fork_params).execute
+
+          if forked_project.errors.any?
+            conflict!(forked_project.errors.messages)
+          else
+            present forked_project, with: Entities::Project,
+                                    user_can_admin_project: can?(current_user, :admin_project, forked_project)
+          end
+        end
+
+        desc 'Update an existing project' do
+          success Entities::Project
+        end
+        params do
+          optional :name, type: String, desc: 'The name of the project'
+          optional :default_branch, type: String, desc: 'The default branch of the project'
+          optional :path, type: String, desc: 'The path of the repository'
+          use :optional_params
+          at_least_one_of :name, :description, :issues_enabled, :merge_requests_enabled,
+            :wiki_enabled, :builds_enabled, :snippets_enabled,
+            :shared_runners_enabled, :container_registry_enabled,
+            :lfs_enabled, :public, :visibility_level, :public_builds,
+            :request_access_enabled, :only_allow_merge_if_build_succeeds,
+            :only_allow_merge_if_all_discussions_are_resolved, :path,
+            :default_branch
+        end
+        put ':id' do
+          authorize_admin_project
+          attrs = map_public_to_visibility_level(declared_params(include_missing: false))
+          authorize! :rename_project, user_project if attrs[:name].present?
+          authorize! :change_visibility_level, user_project if attrs[:visibility_level].present?
+
+          result = ::Projects::UpdateService.new(user_project, current_user, attrs).execute
+
+          if result[:status] == :success
+            present user_project, with: Entities::Project,
+                                  user_can_admin_project: can?(current_user, :admin_project, user_project)
+          else
+            render_validation_error!(user_project)
+          end
+        end
+
+        desc 'Archive a project' do
+          success Entities::Project
+        end
+        post ':id/archive' do
+          authorize!(:archive_project, user_project)
+
+          user_project.archive!
+
+          present user_project, with: Entities::Project
+        end
+
+        desc 'Unarchive a project' do
+          success Entities::Project
+        end
+        post ':id/unarchive' do
+          authorize!(:archive_project, user_project)
+
+          user_project.unarchive!
+
+          present user_project, with: Entities::Project
+        end
+
+        desc 'Star a project' do
+          success Entities::Project
+        end
+        post ':id/star' do
+          if current_user.starred?(user_project)
+            not_modified!
+          else
+            current_user.toggle_star(user_project)
+            user_project.reload
+
+            present user_project, with: Entities::Project
+          end
+        end
+
+        desc 'Unstar a project' do
+          success Entities::Project
+        end
+        delete ':id/star' do
+          if current_user.starred?(user_project)
+            current_user.toggle_star(user_project)
+            user_project.reload
+
+            present user_project, with: Entities::Project
+          else
+            not_modified!
+          end
+        end
+
+        desc 'Remove a project'
+        delete ":id" do
+          authorize! :remove_project, user_project
+          ::Projects::DestroyService.new(user_project, current_user, {}).async_execute
+        end
+
+        desc 'Mark this project as forked from another'
+        params do
+          requires :forked_from_id, type: String, desc: 'The ID of the project it was forked from'
+        end
+        post ":id/fork/:forked_from_id" do
+          authenticated_as_admin!
+
+          forked_from_project = find_project!(params[:forked_from_id])
+          not_found!("Source Project") unless forked_from_project
+
+          if user_project.forked_from_project.nil?
+            user_project.create_forked_project_link(forked_to_project_id: user_project.id, forked_from_project_id: forked_from_project.id)
+          else
+            render_api_error!("Project already forked", 409)
+          end
+        end
+
+        desc 'Remove a forked_from relationship'
+        delete ":id/fork" do
+          authorize! :remove_fork_project, user_project
+
+          if user_project.forked?
+            user_project.forked_project_link.destroy
+          else
+            not_modified!
+          end
+        end
+
+        desc 'Share the project with a group' do
+          success Entities::ProjectGroupLink
+        end
+        params do
+          requires :group_id, type: Integer, desc: 'The ID of a group'
+          requires :group_access, type: Integer, values: Gitlab::Access.values, desc: 'The group access level'
+          optional :expires_at, type: Date, desc: 'Share expiration date'
+        end
+        post ":id/share" do
+          authorize! :admin_project, user_project
+          group = Group.find_by_id(params[:group_id])
+
+          unless group && can?(current_user, :read_group, group)
+            not_found!('Group')
+          end
+
+          unless user_project.allowed_to_share_with_group?
+            return render_api_error!("The project sharing with group is disabled", 400)
+          end
+
+          link = user_project.project_group_links.new(declared_params(include_missing: false))
+
+          if link.save
+            present link, with: Entities::ProjectGroupLink
+          else
+            render_api_error!(link.errors.full_messages.first, 409)
+          end
+        end
+
+        params do
+          requires :group_id, type: Integer, desc: 'The ID of the group'
+        end
+        delete ":id/share/:group_id" do
+          authorize! :admin_project, user_project
+
+          link = user_project.project_group_links.find_by(group_id: params[:group_id])
+          not_found!('Group Link') unless link
+
+          link.destroy
+          no_content!
+        end
+
+        desc 'Upload a file'
+        params do
+          requires :file, type: File, desc: 'The file to be uploaded'
+        end
+        post ":id/uploads" do
+          ::Projects::UploadService.new(user_project, params[:file]).execute
+        end
+
+        desc 'Get the users list of a project' do
+          success Entities::UserBasic
+        end
+        params do
+          optional :search, type: String, desc: 'Return list of users matching the search criteria'
+          use :pagination
+        end
+        get ':id/users' do
+          users = user_project.team.users
+          users = users.search(params[:search]) if params[:search].present?
+
+          present paginate(users), with: Entities::UserBasic
+        end
+      end
+    end
+  end
+end
diff --git a/lib/backup/manager.rb b/lib/backup/manager.rb
index cefbfdce3bb..f099c0651ac 100644
--- a/lib/backup/manager.rb
+++ b/lib/backup/manager.rb
@@ -1,6 +1,6 @@
 module Backup
   class Manager
-    ARCHIVES_TO_BACKUP = %w[uploads builds artifacts lfs registry]
+    ARCHIVES_TO_BACKUP = %w[uploads builds artifacts pages lfs registry]
     FOLDERS_TO_BACKUP = %w[repositories db]
     FILE_NAME_SUFFIX = '_gitlab_backup.tar'
 
diff --git a/lib/backup/pages.rb b/lib/backup/pages.rb
new file mode 100644
index 00000000000..215ded93bfe
--- /dev/null
+++ b/lib/backup/pages.rb
@@ -0,0 +1,13 @@
+require 'backup/files'
+
+module Backup
+  class Pages < Files
+    def initialize
+      super('pages', Gitlab.config.pages.path)
+    end
+
+    def create_files_dir
+      Dir.mkdir(app_files_dir, 0700)
+    end
+  end
+end
diff --git a/lib/gitlab/ci/config/entry/global.rb b/lib/gitlab/ci/config/entry/global.rb
index ede97cc0504..a4ec8f0ff2f 100644
--- a/lib/gitlab/ci/config/entry/global.rb
+++ b/lib/gitlab/ci/config/entry/global.rb
@@ -33,11 +33,8 @@ module Gitlab
           entry :cache, Entry::Cache,
             description: 'Configure caching between build jobs.'
 
-          entry :coverage, Entry::Coverage,
-               description: 'Coverage configuration for this pipeline.'
-
           helpers :before_script, :image, :services, :after_script,
-                  :variables, :stages, :types, :cache, :coverage, :jobs
+                  :variables, :stages, :types, :cache, :jobs
 
           def compose!(_deps = nil)
             super(self) do
diff --git a/lib/gitlab/email/receiver.rb b/lib/gitlab/email/receiver.rb
index a40c44eb1bc..b64db5d01ae 100644
--- a/lib/gitlab/email/receiver.rb
+++ b/lib/gitlab/email/receiver.rb
@@ -35,6 +35,8 @@ module Gitlab
         handler.execute
       end
 
+      private
+
       def build_mail
         Mail::Message.new(@raw)
       rescue Encoding::UndefinedConversionError,
@@ -54,7 +56,24 @@ module Gitlab
       end
 
       def key_from_additional_headers(mail)
-        Array(mail.references).find do |mail_id|
+        references = ensure_references_array(mail.references)
+
+        find_key_from_references(references)
+      end
+
+      def ensure_references_array(references)
+        case references
+        when Array
+          references
+        when String
+          # Handle emails from clients which append with commas,
+          # example clients are Microsoft exchange and iOS app
+          Gitlab::IncomingEmail.scan_fallback_references(references)
+        end
+      end
+
+      def find_key_from_references(references)
+        references.find do |mail_id|
           key = Gitlab::IncomingEmail.key_from_fallback_message_id(mail_id)
           break key if key
         end
diff --git a/lib/gitlab/incoming_email.rb b/lib/gitlab/incoming_email.rb
index b91012d6405..c9122a23568 100644
--- a/lib/gitlab/incoming_email.rb
+++ b/lib/gitlab/incoming_email.rb
@@ -4,8 +4,6 @@ module Gitlab
     WILDCARD_PLACEHOLDER = '%{key}'.freeze
 
     class << self
-      FALLBACK_MESSAGE_ID_REGEX = /\Areply\-(.+)@#{Gitlab.config.gitlab.host}\Z/.freeze
-
       def enabled?
         config.enabled && config.address
       end
@@ -37,10 +35,14 @@ module Gitlab
       end
 
       def key_from_fallback_message_id(mail_id)
-        match = mail_id.match(FALLBACK_MESSAGE_ID_REGEX)
-        return unless match
+        message_id_regexp = /\Areply\-(.+)@#{Gitlab.config.gitlab.host}\z/
 
-        match[1]
+        mail_id[message_id_regexp, 1]
+      end
+
+      def scan_fallback_references(references)
+        # It's looking for each <...>
+        references.scan(/(?!<)[^<>]+(?=>)/)
       end
 
       def config
diff --git a/lib/gitlab/kubernetes.rb b/lib/gitlab/kubernetes.rb
index 288771c1c12..3a7af363548 100644
--- a/lib/gitlab/kubernetes.rb
+++ b/lib/gitlab/kubernetes.rb
@@ -43,10 +43,10 @@ module Gitlab
       end
     end
 
-    def add_terminal_auth(terminal, token, ca_pem = nil)
+    def add_terminal_auth(terminal, token:, max_session_time:, ca_pem: nil)
       terminal[:headers]['Authorization'] << "Bearer #{token}"
+      terminal[:max_session_time] = max_session_time
       terminal[:ca_pem] = ca_pem if ca_pem.present?
-      terminal
     end
 
     def container_exec_url(api_url, namespace, pod_name, container_name)
diff --git a/lib/gitlab/pages_transfer.rb b/lib/gitlab/pages_transfer.rb
new file mode 100644
index 00000000000..fb215f27cbd
--- /dev/null
+++ b/lib/gitlab/pages_transfer.rb
@@ -0,0 +1,7 @@
+module Gitlab
+  class PagesTransfer < ProjectTransfer
+    def root_dir
+      Gitlab.config.pages.path
+    end
+  end
+end
diff --git a/lib/gitlab/project_transfer.rb b/lib/gitlab/project_transfer.rb
new file mode 100644
index 00000000000..1bba0b78e2f
--- /dev/null
+++ b/lib/gitlab/project_transfer.rb
@@ -0,0 +1,35 @@
+module Gitlab
+  class ProjectTransfer
+    def move_project(project_path, namespace_path_was, namespace_path)
+      new_namespace_folder = File.join(root_dir, namespace_path)
+      FileUtils.mkdir_p(new_namespace_folder) unless Dir.exist?(new_namespace_folder)
+      from = File.join(root_dir, namespace_path_was, project_path)
+      to = File.join(root_dir, namespace_path, project_path)
+      move(from, to, "")
+    end
+
+    def rename_project(path_was, path, namespace_path)
+      base_dir = File.join(root_dir, namespace_path)
+      move(path_was, path, base_dir)
+    end
+
+    def rename_namespace(path_was, path)
+      move(path_was, path)
+    end
+
+    def root_dir
+      raise NotImplementedError
+    end
+
+    private
+
+    def move(path_was, path, base_dir = nil)
+      base_dir = root_dir unless base_dir
+      from = File.join(base_dir, path_was)
+      to = File.join(base_dir, path)
+      FileUtils.mv(from, to)
+    rescue Errno::ENOENT
+      false
+    end
+  end
+end
diff --git a/lib/gitlab/serialize/ci/variables.rb b/lib/gitlab/serializer/ci/variables.rb
index 3a9443bfcd9..c059c454eac 100644
--- a/lib/gitlab/serialize/ci/variables.rb
+++ b/lib/gitlab/serializer/ci/variables.rb
@@ -1,5 +1,5 @@
 module Gitlab
-  module Serialize
+  module Serializer
     module Ci
       # This serializer could make sure our YAML variables' keys and values
       # are always strings. This is more for legacy build data because
diff --git a/lib/gitlab/serializer/pagination.rb b/lib/gitlab/serializer/pagination.rb
new file mode 100644
index 00000000000..bf2c0acc729
--- /dev/null
+++ b/lib/gitlab/serializer/pagination.rb
@@ -0,0 +1,36 @@
+module Gitlab
+  module Serializer
+    class Pagination
+      class InvalidResourceError < StandardError; end
+      include ::API::Helpers::Pagination
+
+      def initialize(request, response)
+        @request = request
+        @response = response
+      end
+
+      def paginate(resource)
+        if resource.respond_to?(:page)
+          super(resource)
+        else
+          raise InvalidResourceError
+        end
+      end
+
+      private
+
+      # Methods needed by `API::Helpers::Pagination`
+      #
+
+      attr_reader :request
+
+      def params
+        @request.query_parameters
+      end
+
+      def header(header, value)
+        @response.headers[header] = value
+      end
+    end
+  end
+end
diff --git a/lib/gitlab/uploads_transfer.rb b/lib/gitlab/uploads_transfer.rb
index be8fcc7b2d2..81701831a6a 100644
--- a/lib/gitlab/uploads_transfer.rb
+++ b/lib/gitlab/uploads_transfer.rb
@@ -1,33 +1,5 @@
 module Gitlab
-  class UploadsTransfer
-    def move_project(project_path, namespace_path_was, namespace_path)
-      new_namespace_folder = File.join(root_dir, namespace_path)
-      FileUtils.mkdir_p(new_namespace_folder) unless Dir.exist?(new_namespace_folder)
-      from = File.join(root_dir, namespace_path_was, project_path)
-      to = File.join(root_dir, namespace_path, project_path)
-      move(from, to, "")
-    end
-
-    def rename_project(path_was, path, namespace_path)
-      base_dir = File.join(root_dir, namespace_path)
-      move(path_was, path, base_dir)
-    end
-
-    def rename_namespace(path_was, path)
-      move(path_was, path)
-    end
-
-    private
-
-    def move(path_was, path, base_dir = nil)
-      base_dir = root_dir unless base_dir
-      from = File.join(base_dir, path_was)
-      to = File.join(base_dir, path)
-      FileUtils.mv(from, to)
-    rescue Errno::ENOENT
-      false
-    end
-
+  class UploadsTransfer < ProjectTransfer
     def root_dir
       File.join(Rails.root, "public", "uploads")
     end
diff --git a/lib/gitlab/visibility_level.rb b/lib/gitlab/visibility_level.rb
index c7953af29dd..a4e966e4016 100644
--- a/lib/gitlab/visibility_level.rb
+++ b/lib/gitlab/visibility_level.rb
@@ -13,7 +13,19 @@ module Gitlab
       scope :public_and_internal_only,  -> { where(visibility_level: [PUBLIC, INTERNAL] ) }
       scope :non_public_only,           -> { where.not(visibility_level: PUBLIC) }
 
-      scope :public_to_user, -> (user) { user && !user.external ? public_and_internal_only : public_only }
+      scope :public_to_user, -> (user) do
+        if user
+          if user.admin?
+            all
+          elsif !user.external?
+            public_and_internal_only
+          else
+            public_only
+          end
+        else
+          public_only
+        end
+      end
     end
 
     PRIVATE  = 0 unless const_defined?(:PRIVATE)
diff --git a/lib/gitlab/workhorse.rb b/lib/gitlab/workhorse.rb
index a3b502ffd6a..c8872df8a93 100644
--- a/lib/gitlab/workhorse.rb
+++ b/lib/gitlab/workhorse.rb
@@ -107,7 +107,8 @@ module Gitlab
           'Terminal' => {
             'Subprotocols' => terminal[:subprotocols],
             'Url' => terminal[:url],
-            'Header' => terminal[:headers]
+            'Header' => terminal[:headers],
+            'MaxSessionTime' => terminal[:max_session_time],
           }
         }
         details['Terminal']['CAPem'] = terminal[:ca_pem] if terminal.has_key?(:ca_pem)
diff --git a/lib/support/init.d/gitlab b/lib/support/init.d/gitlab
index 31b00ff128a..97414ead3dd 100755
--- a/lib/support/init.d/gitlab
+++ b/lib/support/init.d/gitlab
@@ -42,6 +42,11 @@ gitlab_workhorse_dir=$(cd $app_root/../gitlab-workhorse 2> /dev/null && pwd)
 gitlab_workhorse_pid_path="$pid_path/gitlab-workhorse.pid"
 gitlab_workhorse_options="-listenUmask 0 -listenNetwork unix -listenAddr $socket_path/gitlab-workhorse.socket -authBackend http://127.0.0.1:8080 -authSocket $rails_socket -documentRoot $app_root/public"
 gitlab_workhorse_log="$app_root/log/gitlab-workhorse.log"
+gitlab_pages_enabled=false
+gitlab_pages_dir=$(cd $app_root/../gitlab-pages 2> /dev/null && pwd)
+gitlab_pages_pid_path="$pid_path/gitlab-pages.pid"
+gitlab_pages_options="-pages-domain example.com -pages-root $app_root/shared/pages -listen-proxy 127.0.0.1:8090"
+gitlab_pages_log="$app_root/log/gitlab-pages.log"
 shell_path="/bin/bash"
 
 # Read configuration variable file if it is present
@@ -89,13 +94,20 @@ check_pids(){
       mpid=0
     fi
   fi
+  if [ "$gitlab_pages_enabled" = true ]; then
+    if [ -f "$gitlab_pages_pid_path" ]; then
+      gppid=$(cat "$gitlab_pages_pid_path")
+    else
+      gppid=0
+    fi
+  fi
 }
 
 ## Called when we have started the two processes and are waiting for their pid files.
 wait_for_pids(){
   # We are sleeping a bit here mostly because sidekiq is slow at writing its pid
   i=0;
-  while [ ! -f $web_server_pid_path ] || [ ! -f $sidekiq_pid_path ] || [ ! -f $gitlab_workhorse_pid_path ] || { [ "$mail_room_enabled" = true ] && [ ! -f $mail_room_pid_path ]; }; do
+  while [ ! -f $web_server_pid_path ] || [ ! -f $sidekiq_pid_path ] || [ ! -f $gitlab_workhorse_pid_path ] || { [ "$mail_room_enabled" = true ] && [ ! -f $mail_room_pid_path ] || { [ "$gitlab_pages_enabled" = true ] && [ ! -f $gitlab_pages_pid_path ]; }; do
     sleep 0.1;
     i=$((i+1))
     if [ $((i%10)) = 0 ]; then
@@ -144,7 +156,15 @@ check_status(){
       mail_room_status="-1"
     fi
   fi
-  if [ $web_status = 0 ] && [ $sidekiq_status = 0 ] && [ $gitlab_workhorse_status = 0 ] && { [ "$mail_room_enabled" != true ] || [ $mail_room_status = 0 ]; }; then
+  if [ "$gitlab_pages_enabled" = true ]; then
+    if [ $gppid -ne 0 ]; then
+      kill -0 "$gppid" 2>/dev/null
+      gitlab_pages_status="$?"
+    else
+      gitlab_pages_status="-1"
+    fi
+  fi
+  if [ $web_status = 0 ] && [ $sidekiq_status = 0 ] && [ $gitlab_workhorse_status = 0 ] && { [ "$mail_room_enabled" != true ] || [ $mail_room_status = 0 ]; } && { [ "$gitlab_pages_enabled" != true ] || [ $gitlab_pages_status = 0 ]; }; then
     gitlab_status=0
   else
     # http://refspecs.linuxbase.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
@@ -186,12 +206,19 @@ check_stale_pids(){
       exit 1
     fi
   fi
+  if [ "$gitlab_pages_enabled" = true ] && [ "$gppid" != "0" ] && [ "$gitlab_pages_status" != "0" ]; then
+    echo "Removing stale GitLab Pages job dispatcher pid. This is most likely caused by GitLab Pages crashing the last time it ran."
+    if ! rm "$gitlab_pages_pid_path"; then
+      echo "Unable to remove stale pid, exiting"
+      exit 1
+    fi
+  fi
 }
 
 ## If no parts of the service is running, bail out.
 exit_if_not_running(){
   check_stale_pids
-  if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; }; then
+  if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; } && { [ "$gitlab_pages_enabled" != true ] || [ "$gitlab_pages_status" != "0" ]; }; then
     echo "GitLab is not running."
     exit
   fi
@@ -213,6 +240,9 @@ start_gitlab() {
   if [ "$mail_room_enabled" = true ] && [ "$mail_room_status" != "0" ]; then
     echo "Starting GitLab MailRoom"
   fi
+  if [ "$gitlab_pages_enabled" = true ] && [ "$gitlab_pages_status" != "0" ]; then
+    echo "Starting GitLab Pages"
+  fi
 
   # Then check if the service is running. If it is: don't start again.
   if [ "$web_status" = "0" ]; then
@@ -252,6 +282,16 @@ start_gitlab() {
     fi
   fi
 
+  if [ "$gitlab_pages_enabled" = true ]; then
+    if [ "$gitlab_pages_status" = "0" ]; then
+      echo "The GitLab Pages is already running with pid $spid, not restarting"
+    else
+      $app_root/bin/daemon_with_pidfile $gitlab_pages_pid_path  \
+          $gitlab_pages_dir/gitlab-pages $gitlab_pages_options \
+        >> $gitlab_pages_log 2>&1 &
+    fi
+  fi
+
   # Wait for the pids to be planted
   wait_for_pids
   # Finally check the status to tell wether or not GitLab is running
@@ -278,13 +318,17 @@ stop_gitlab() {
     echo "Shutting down GitLab MailRoom"
     RAILS_ENV=$RAILS_ENV bin/mail_room stop
   fi
+  if [ "$gitlab_pages_status" = "0" ]; then
+    echo "Shutting down gitlab-pages"
+    kill -- $(cat $gitlab_pages_pid_path)
+  fi
 
   # If something needs to be stopped, lets wait for it to stop. Never use SIGKILL in a script.
-  while [ "$web_status" = "0" ] || [ "$sidekiq_status" = "0" ] || [ "$gitlab_workhorse_status" = "0" ] || { [ "$mail_room_enabled" = true ] && [ "$mail_room_status" = "0" ]; }; do
+  while [ "$web_status" = "0" ] || [ "$sidekiq_status" = "0" ] || [ "$gitlab_workhorse_status" = "0" ] || { [ "$mail_room_enabled" = true ] && [ "$mail_room_status" = "0" ]; } || { [ "$gitlab_pages_enabled" = true ] && [ "$gitlab_pages_status" = "0" ]; }; do
     sleep 1
     check_status
     printf "."
-    if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; }; then
+    if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; } && { [ "$gitlab_pages_enabled" != true ] || [ "$gitlab_pages_status" != "0" ]; }; then
       printf "\n"
       break
     fi
@@ -298,6 +342,7 @@ stop_gitlab() {
   if [ "$mail_room_enabled" = true ]; then
     rm "$mail_room_pid_path" 2>/dev/null
   fi
+  rm -f "$gitlab_pages_pid_path"
 
   print_status
 }
@@ -305,7 +350,7 @@ stop_gitlab() {
 ## Prints the status of GitLab and its components.
 print_status() {
   check_status
-  if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; }; then
+  if [ "$web_status" != "0" ] && [ "$sidekiq_status" != "0" ] && [ "$gitlab_workhorse_status" != "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" != "0" ]; } && { [ "$gitlab_pages_enabled" != true ] || [ "$gitlab_pages_status" != "0" ]; }; then
     echo "GitLab is not running."
     return
   fi
@@ -331,7 +376,14 @@ print_status() {
         printf "The GitLab MailRoom email processor is \033[31mnot running\033[0m.\n"
     fi
   fi
-  if [ "$web_status" = "0" ] && [ "$sidekiq_status" = "0" ] && [ "$gitlab_workhorse_status" = "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" = "0" ]; }; then
+  if [ "$gitlab_pages_enabled" = true ]; then
+    if [ "$gitlab_pages_status" = "0" ]; then
+        echo "The GitLab Pages with pid $mpid is running."
+    else
+        printf "The GitLab Pages is \033[31mnot running\033[0m.\n"
+    fi
+  fi
+  if [ "$web_status" = "0" ] && [ "$sidekiq_status" = "0" ] && [ "$gitlab_workhorse_status" = "0" ] && { [ "$mail_room_enabled" != true ] || [ "$mail_room_status" = "0" ]; } && { [ "$gitlab_pages_enabled" != true ] || [ "$gitlab_pages_status" = "0" ]; }; then
     printf "GitLab and all its components are \033[32mup and running\033[0m.\n"
   fi
 }
@@ -362,7 +414,7 @@ reload_gitlab(){
 ## Restarts Sidekiq and Unicorn.
 restart_gitlab(){
   check_status
-  if [ "$web_status" = "0" ] || [ "$sidekiq_status" = "0" ] || [ "$gitlab_workhorse" = "0" ] || { [ "$mail_room_enabled" = true ] && [ "$mail_room_status" = "0" ]; }; then
+  if [ "$web_status" = "0" ] || [ "$sidekiq_status" = "0" ] || [ "$gitlab_workhorse" = "0" ] || { [ "$mail_room_enabled" = true ] && [ "$mail_room_status" = "0" ]; } || { [ "$gitlab_pages_enabled" = true ] && [ "$gitlab_pages_status" = "0" ]; }; then
     stop_gitlab
   fi
   start_gitlab
diff --git a/lib/support/init.d/gitlab.default.example b/lib/support/init.d/gitlab.default.example
index cc8617b72ca..e5797d8fe3c 100755..100644
--- a/lib/support/init.d/gitlab.default.example
+++ b/lib/support/init.d/gitlab.default.example
@@ -47,6 +47,30 @@ gitlab_workhorse_pid_path="$pid_path/gitlab-workhorse.pid"
 gitlab_workhorse_options="-listenUmask 0 -listenNetwork unix -listenAddr $socket_path/gitlab-workhorse.socket -authBackend http://127.0.0.1:8080 -authSocket $socket_path/gitlab.socket -documentRoot $app_root/public"
 gitlab_workhorse_log="$app_root/log/gitlab-workhorse.log"
 
+# The GitLab Pages Daemon needs either a separate IP address on which it will
+# listen or use different ports than 80 or 443 that will be forwarded to GitLab
+# Pages Daemon.
+#
+# To enable HTTP support for custom domains add the `-listen-http` directive
+# in `gitlab_pages_options` below.
+# The value of -listen-http must be set to `gitlab.yml > pages > external_http`
+# as well. For example:
+#
+#   -listen-http 1.1.1.1:80
+#
+# To enable HTTPS support for custom domains add the `-listen-https`,
+# `-root-cert` and `-root-key` directives in `gitlab_pages_options` below.
+# The value of -listen-https must be set to `gitlab.yml > pages > external_https`
+# as well. For example:
+#
+#   -listen-https 1.1.1.1:443 -root-cert /path/to/example.com.crt -root-key /path/to/example.com.key
+#
+# The -pages-domain must be specified the same as in `gitlab.yml > pages > host`.
+# Set `gitlab_pages_enabled=true` if you want to enable the Pages feature.
+gitlab_pages_enabled=false
+gitlab_pages_options="-pages-domain example.com -pages-root $app_root/shared/pages -listen-proxy 127.0.0.1:8090"
+gitlab_pages_log="$app_root/log/gitlab-pages.log"
+
 # mail_room_enabled specifies whether mail_room, which is used to process incoming email, is enabled.
 # This is required for the Reply by email feature.
 # The default is "false"
diff --git a/lib/support/nginx/gitlab-pages b/lib/support/nginx/gitlab-pages
new file mode 100644
index 00000000000..d9746c5c1aa
--- /dev/null
+++ b/lib/support/nginx/gitlab-pages
@@ -0,0 +1,28 @@
+## GitLab
+##
+
+## Pages serving host
+server {
+  listen 0.0.0.0:80;
+  listen [::]:80 ipv6only=on;
+
+  ## Replace this with something like pages.gitlab.com
+  server_name ~^.*\.YOUR_GITLAB_PAGES\.DOMAIN$;
+
+  ## Individual nginx logs for GitLab pages
+  access_log  /var/log/nginx/gitlab_pages_access.log;
+  error_log   /var/log/nginx/gitlab_pages_error.log;
+
+  location / {
+    proxy_set_header    Host                $http_host;
+    proxy_set_header    X-Real-IP           $remote_addr;
+    proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
+    proxy_set_header    X-Forwarded-Proto   $scheme;
+    # The same address as passed to GitLab Pages: `-listen-proxy`
+    proxy_pass          http://localhost:8090/;
+  }
+
+  # Define custom error pages
+  error_page 403 /403.html;
+  error_page 404 /404.html;
+}
diff --git a/lib/support/nginx/gitlab-pages-ssl b/lib/support/nginx/gitlab-pages-ssl
new file mode 100644
index 00000000000..a1ccf266835
--- /dev/null
+++ b/lib/support/nginx/gitlab-pages-ssl
@@ -0,0 +1,77 @@
+## GitLab
+##
+
+## Redirects all HTTP traffic to the HTTPS host
+server {
+  ## Either remove "default_server" from the listen line below,
+  ## or delete the /etc/nginx/sites-enabled/default file. This will cause gitlab
+  ## to be served if you visit any address that your server responds to, eg.
+  ## the ip address of the server (http://x.x.x.x/)
+  listen 0.0.0.0:80;
+  listen [::]:80 ipv6only=on;
+
+  ## Replace this with something like pages.gitlab.com
+  server_name ~^.*\.YOUR_GITLAB_PAGES\.DOMAIN$;
+  server_tokens off; ## Don't show the nginx version number, a security best practice
+
+  return 301  https://$http_host$request_uri;
+
+  access_log  /var/log/nginx/gitlab_pages_access.log;
+  error_log   /var/log/nginx/gitlab_pages_access.log;
+}
+
+## Pages serving host
+server {
+  listen 0.0.0.0:443 ssl;
+  listen [::]:443 ipv6only=on ssl http2;
+
+  ## Replace this with something like pages.gitlab.com
+  server_name ~^.*\.YOUR_GITLAB_PAGES\.DOMAIN$;
+  server_tokens off; ## Don't show the nginx version number, a security best practice
+
+  ## Strong SSL Security
+  ## https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html & https://cipherli.st/
+  ssl on;
+  ssl_certificate /etc/nginx/ssl/gitlab-pages.crt;
+  ssl_certificate_key /etc/nginx/ssl/gitlab-pages.key;
+
+  # GitLab needs backwards compatible ciphers to retain compatibility with Java IDEs
+  ssl_ciphers "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4";
+  ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
+  ssl_prefer_server_ciphers on;
+  ssl_session_cache shared:SSL:10m;
+  ssl_session_timeout 5m;
+
+  ## See app/controllers/application_controller.rb for headers set
+
+  ## [Optional] If your certficate has OCSP, enable OCSP stapling to reduce the overhead and latency of running SSL.
+  ## Replace with your ssl_trusted_certificate. For more info see:
+  ## - https://medium.com/devops-programming/4445f4862461
+  ## - https://www.ruby-forum.com/topic/4419319
+  ## - https://www.digitalocean.com/community/tutorials/how-to-configure-ocsp-stapling-on-apache-and-nginx
+  # ssl_stapling on;
+  # ssl_stapling_verify on;
+  # ssl_trusted_certificate /etc/nginx/ssl/stapling.trusted.crt;
+
+  ## [Optional] Generate a stronger DHE parameter:
+  ##   sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
+  ##
+  # ssl_dhparam /etc/ssl/certs/dhparam.pem;
+
+  ## Individual nginx logs for GitLab pages
+  access_log  /var/log/nginx/gitlab_pages_access.log;
+  error_log   /var/log/nginx/gitlab_pages_error.log;
+
+  location / {
+    proxy_set_header    Host                $http_host;
+    proxy_set_header    X-Real-IP           $remote_addr;
+    proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
+    proxy_set_header    X-Forwarded-Proto   $scheme;
+    # The same address as passed to GitLab Pages: `-listen-proxy`
+    proxy_pass          http://localhost:8090/;
+  }
+
+  # Define custom error pages
+  error_page 403 /403.html;
+  error_page 404 /404.html;
+}
diff --git a/lib/tasks/gitlab/backup.rake b/lib/tasks/gitlab/backup.rake
index a9f1255e8cf..ffab6f492fb 100644
--- a/lib/tasks/gitlab/backup.rake
+++ b/lib/tasks/gitlab/backup.rake
@@ -13,6 +13,7 @@ namespace :gitlab do
       Rake::Task["gitlab:backup:uploads:create"].invoke
       Rake::Task["gitlab:backup:builds:create"].invoke
       Rake::Task["gitlab:backup:artifacts:create"].invoke
+      Rake::Task["gitlab:backup:pages:create"].invoke
       Rake::Task["gitlab:backup:lfs:create"].invoke
       Rake::Task["gitlab:backup:registry:create"].invoke
 
@@ -56,6 +57,7 @@ namespace :gitlab do
       Rake::Task['gitlab:backup:uploads:restore'].invoke unless backup.skipped?('uploads')
       Rake::Task['gitlab:backup:builds:restore'].invoke unless backup.skipped?('builds')
       Rake::Task['gitlab:backup:artifacts:restore'].invoke unless backup.skipped?('artifacts')
+      Rake::Task["gitlab:backup:pages:restore"].invoke unless backup.skipped?("pages")
       Rake::Task['gitlab:backup:lfs:restore'].invoke unless backup.skipped?('lfs')
       Rake::Task['gitlab:backup:registry:restore'].invoke unless backup.skipped?('registry')
       Rake::Task['gitlab:shell:setup'].invoke
@@ -159,6 +161,25 @@ namespace :gitlab do
       end
     end
 
+    namespace :pages do
+      task create: :environment do
+        $progress.puts "Dumping pages ... ".blue
+
+        if ENV["SKIP"] && ENV["SKIP"].include?("pages")
+          $progress.puts "[SKIPPED]".cyan
+        else
+          Backup::Pages.new.dump
+          $progress.puts "done".green
+        end
+      end
+
+      task restore: :environment do
+        $progress.puts "Restoring pages ... ".blue
+        Backup::Pages.new.restore
+        $progress.puts "done".green
+      end
+    end
+
     namespace :lfs do
       task create: :environment do
         $progress.puts "Dumping lfs objects ... ".color(:blue)
diff --git a/lib/tasks/grape.rake b/lib/tasks/grape.rake
index 9980e0b7984..ea2698da606 100644
--- a/lib/tasks/grape.rake
+++ b/lib/tasks/grape.rake
@@ -2,7 +2,11 @@ namespace :grape do
   desc 'Print compiled grape routes'
   task routes: :environment do
     API::API.routes.each do |route|
-      puts route
+      puts "#{route.options[:method]} #{route.path} - #{route_description(route.options)}"
     end
   end
+
+  def route_description(options)
+    options[:settings][:description][:description] if options[:settings][:description]
+  end
 end