Fix whitespace in install and integration docs

Many code blocks are 4spaced, and they render in GitLab
without coloring as a result, even though they are
fenced with a language label. If in a list, other items
will render as being in a code block too, even if not
meant to. This fixes all these issues, and cleans up
minor white space issues in install and integration docs

14 files changed, 801 insertions, 780 deletions

diff --git a/doc/integration/auth0.md b/doc/integration/auth0.md
index c67375ede50..5061b863e79 100644
--- a/doc/integration/auth0.md
+++ b/doc/integration/auth0.md
@@ -16,64 +16,64 @@ application.
 1. At the top of the Settings screen, you should see your Domain, Client ID and
    Client Secret. Take note of these as you'll need to put them in the
    configuration file. For example:
-    - Domain: `test1234.auth0.com`
-    - Client ID: `t6X8L2465bNePWLOvt9yi41i`
-    - Client Secret: `KbveM3nqfjwCbrhaUy_gDu2dss8TIlHIdzlyf33pB7dEK5u_NyQdp65O_o02hXs2`
+   - Domain: `test1234.auth0.com`
+   - Client ID: `t6X8L2465bNePWLOvt9yi41i`
+   - Client Secret: `KbveM3nqfjwCbrhaUy_gDu2dss8TIlHIdzlyf33pB7dEK5u_NyQdp65O_o02hXs2`
 
 1. Fill in the Allowed Callback URLs:
-    - `http://YOUR_GITLAB_URL/users/auth/auth0/callback` (or)
-    - `https://YOUR_GITLAB_URL/users/auth/auth0/callback`
+   - `http://YOUR_GITLAB_URL/users/auth/auth0/callback` (or)
+   - `https://YOUR_GITLAB_URL/users/auth/auth0/callback`
 
 1. Fill in the Allowed Origins (CORS):
-    - `http://YOUR_GITLAB_URL` (or)
-    - `https://YOUR_GITLAB_URL`
+   - `http://YOUR_GITLAB_URL` (or)
+   - `https://YOUR_GITLAB_URL`
 
 1. On your GitLab server, open the configuration file.
 
-    For omnibus package:
+   For omnibus package:
 
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-      cd /home/git/gitlab
-      sudo -u git -H editor config/gitlab.yml
-    ```
+   ```sh
+   cd /home/git/gitlab
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
 1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration)
    for initial settings.
 
 1. Add the provider configuration:
 
-    For omnibus package:
-
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "auth0",
-          "args" => { client_id: 'YOUR_AUTH0_CLIENT_ID',
-                      client_secret: 'YOUR_AUTH0_CLIENT_SECRET',
-                      domain: 'YOUR_AUTH0_DOMAIN',
-                      scope: 'openid profile email'
-                    }
-        }
-      ]
-    ```
-
-    For installations from source:
-
-    ```yaml
-      - { name: 'auth0',
-          args: {
-            client_id: 'YOUR_AUTH0_CLIENT_ID',
-            client_secret: 'YOUR_AUTH0_CLIENT_SECRET',
-            domain: 'YOUR_AUTH0_DOMAIN',
-            scope: 'openid profile email' }
-        }
-    ```
+   For omnibus package:
+
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "auth0",
+       "args" => { client_id: 'YOUR_AUTH0_CLIENT_ID',
+                   client_secret: 'YOUR_AUTH0_CLIENT_SECRET',
+                   domain: 'YOUR_AUTH0_DOMAIN',
+                   scope: 'openid profile email'
+                 }
+     }
+   ]
+   ```
+
+   For installations from source:
+
+   ```yaml
+   - { name: 'auth0',
+       args: {
+         client_id: 'YOUR_AUTH0_CLIENT_ID',
+         client_secret: 'YOUR_AUTH0_CLIENT_SECRET',
+         domain: 'YOUR_AUTH0_DOMAIN',
+         scope: 'openid profile email' }
+     }
+   ```
 
 1. Change `YOUR_AUTH0_CLIENT_ID` to the client ID from the Auth0 Console page
    from step 5.
@@ -81,8 +81,8 @@ application.
 1. Change `YOUR_AUTH0_CLIENT_SECRET` to the client secret from the Auth0 Console
    page from step 5.
 
-1.  [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be an Auth0 icon below the regular sign in
 form. Click the icon to begin the authentication process. Auth0 will ask the
diff --git a/doc/integration/bitbucket.md b/doc/integration/bitbucket.md
index 68ec8c4b5c2..5d8f2ebcb8b 100644
--- a/doc/integration/bitbucket.md
+++ b/doc/integration/bitbucket.md
@@ -30,97 +30,97 @@ To enable the Bitbucket OmniAuth provider you must register your application
 with Bitbucket.org. Bitbucket will generate an application ID and secret key for
 you to use.
 
-1.  Sign in to [Bitbucket.org](https://bitbucket.org).
-1.  Navigate to your individual user settings (**Bitbucket settings**) or a team's
-    settings (**Manage team**), depending on how you want the application registered.
-    It does not matter if the application is registered as an individual or a
-    team, that is entirely up to you.
-1.  Select **OAuth** in the left menu under "Access Management".
-1.  Select **Add consumer**.
-1.  Provide the required details:
-
-    | Item | Description |
-    | :--- | :---------- |
-    | **Name** | This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive. |
-    | **Application description** | Fill this in if you wish. |
-    | **Callback URL** | The URL to your GitLab installation, e.g., `https://gitlab.example.com/users/auth`. |
-    | **URL** | The URL to your GitLab installation, e.g., `https://gitlab.example.com`. |
-
-    NOTE: Be sure to append `/users/auth` to the end of the callback URL
-    to prevent a [OAuth2 convert
-    redirect](http://tetraph.com/covert_redirect/) vulnerability.
-
-    NOTE: Starting in GitLab 8.15, you MUST specify a callback URL, or you will
-    see an "Invalid redirect_uri" message. For more details, see [the
-    Bitbucket documentation](https://confluence.atlassian.com/bitbucket/oauth-faq-338365710.html).
-
-    And grant at least the following permissions:
-
-    ```
-    Account: Email, Read
-    Projects: Read
-    Repositories: Read
-    Pull Requests: Read
-    Issues: Read
-    Wiki: Read and Write
-    ```
-
-    ![Bitbucket OAuth settings page](img/bitbucket_oauth_settings_page.png)
-
-1.  Select **Save**.
-1.  Select your newly created OAuth consumer and you should now see a Key and
-    Secret in the list of OAuth consumers. Keep this page open as you continue
-    the configuration.
-
-      ![Bitbucket OAuth key](img/bitbucket_oauth_keys.png)
-
-1.  On your GitLab server, open the configuration file:
-
-    ```
-    # For Omnibus packages
-    sudo editor /etc/gitlab/gitlab.rb
-
-    # For installations from source
-    sudo -u git -H editor /home/git/gitlab/config/gitlab.yml
-    ```
-
-1.  Add the Bitbucket provider configuration:
-
-    For Omnibus packages:
-
-    ```ruby
-    gitlab_rails['omniauth_enabled'] = true
-
-    gitlab_rails['omniauth_providers'] = [
-      {
-        "name" => "bitbucket",
-        "app_id" => "BITBUCKET_APP_KEY",
-        "app_secret" => "BITBUCKET_APP_SECRET",
-        "url" => "https://bitbucket.org/"
-      }
-    ]
-    ```
-
-    For installations from source:
-
-    ```yaml
-    omniauth:
-      enabled: true
-      providers:
-        - { name: 'bitbucket',
-            app_id: 'BITBUCKET_APP_KEY',
-            app_secret: 'BITBUCKET_APP_SECRET',
-            url: 'https://bitbucket.org/' }
-    ```
-
-    ---
-
-    Where `BITBUCKET_APP_KEY` is the Key and `BITBUCKET_APP_SECRET` the Secret
-    from the Bitbucket application page.
-
-1.  Save the configuration file.
-1.  For the changes to take effect, [reconfigure GitLab][] if you installed via
-    Omnibus, or [restart][] if installed from source.
+1. Sign in to [Bitbucket.org](https://bitbucket.org).
+1. Navigate to your individual user settings (**Bitbucket settings**) or a team's
+   settings (**Manage team**), depending on how you want the application registered.
+   It does not matter if the application is registered as an individual or a
+   team, that is entirely up to you.
+1. Select **OAuth** in the left menu under "Access Management".
+1. Select **Add consumer**.
+1. Provide the required details:
+
+   | Item | Description |
+   | :--- | :---------- |
+   | **Name** | This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive. |
+   | **Application description** | Fill this in if you wish. |
+   | **Callback URL** | The URL to your GitLab installation, e.g., `https://gitlab.example.com/users/auth`. |
+   | **URL** | The URL to your GitLab installation, e.g., `https://gitlab.example.com`. |
+
+   NOTE: Be sure to append `/users/auth` to the end of the callback URL
+   to prevent a [OAuth2 convert
+   redirect](http://tetraph.com/covert_redirect/) vulnerability.
+
+   NOTE: Starting in GitLab 8.15, you MUST specify a callback URL, or you will
+   see an "Invalid redirect_uri" message. For more details, see [the
+   Bitbucket documentation](https://confluence.atlassian.com/bitbucket/oauth-faq-338365710.html).
+
+   And grant at least the following permissions:
+
+   ```
+   Account: Email, Read
+   Projects: Read
+   Repositories: Read
+   Pull Requests: Read
+   Issues: Read
+   Wiki: Read and Write
+   ```
+
+   ![Bitbucket OAuth settings page](img/bitbucket_oauth_settings_page.png)
+
+1. Select **Save**.
+1. Select your newly created OAuth consumer and you should now see a Key and
+   Secret in the list of OAuth consumers. Keep this page open as you continue
+   the configuration.
+
+   ![Bitbucket OAuth key](img/bitbucket_oauth_keys.png)
+
+1. On your GitLab server, open the configuration file:
+
+   ```
+   # For Omnibus packages
+   sudo editor /etc/gitlab/gitlab.rb
+
+   # For installations from source
+   sudo -u git -H editor /home/git/gitlab/config/gitlab.yml
+   ```
+
+1. Add the Bitbucket provider configuration:
+
+   For Omnibus packages:
+
+   ```ruby
+   gitlab_rails['omniauth_enabled'] = true
+
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "bitbucket",
+       "app_id" => "BITBUCKET_APP_KEY",
+       "app_secret" => "BITBUCKET_APP_SECRET",
+       "url" => "https://bitbucket.org/"
+     }
+   ]
+   ```
+
+   For installations from source:
+
+   ```yaml
+   omniauth:
+     enabled: true
+     providers:
+       - { name: 'bitbucket',
+           app_id: 'BITBUCKET_APP_KEY',
+           app_secret: 'BITBUCKET_APP_SECRET',
+           url: 'https://bitbucket.org/' }
+   ```
+
+   ---
+
+   Where `BITBUCKET_APP_KEY` is the Key and `BITBUCKET_APP_SECRET` the Secret
+   from the Bitbucket application page.
+
+1. Save the configuration file.
+1. For the changes to take effect, [reconfigure GitLab][] if you installed via
+   Omnibus, or [restart][] if installed from source.
 
 On the sign in page there should now be a Bitbucket icon below the regular sign
 in form. Click the icon to begin the authentication process. Bitbucket will ask
diff --git a/doc/integration/cas.md b/doc/integration/cas.md
index c6178fa44f0..f99337376a8 100644
--- a/doc/integration/cas.md
+++ b/doc/integration/cas.md
@@ -2,63 +2,63 @@
 
 To enable the CAS OmniAuth provider you must register your application with your CAS instance. This requires the service URL GitLab will supply to CAS. It should be something like: `https://gitlab.example.com:443/users/auth/cas3/callback?url`. By default handling for SLO is enabled, you only need to configure CAS for backchannel logout.
 
-1.  On your GitLab server, open the configuration file.
+1. On your GitLab server, open the configuration file.
 
-    For omnibus package:
+   For omnibus package:
 
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-      cd /home/git/gitlab
+   ```sh
+   cd /home/git/gitlab
 
-      sudo -u git -H editor config/gitlab.yml
-    ```
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 
-1.  Add the provider configuration:
+1. Add the provider configuration:
 
-    For omnibus package:
+   For omnibus package:
 
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-            "name"=> "cas3",
-            "label"=> "cas",
-            "args"=> {
-                "url"=> 'CAS_SERVER',
-                "login_url"=> '/CAS_PATH/login',
-                "service_validate_url"=> '/CAS_PATH/p3/serviceValidate',
-                "logout_url"=> '/CAS_PATH/logout'
-            }
-        }
-      ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+         "name"=> "cas3",
+         "label"=> "cas",
+         "args"=> {
+             "url"=> 'CAS_SERVER',
+             "login_url"=> '/CAS_PATH/login',
+             "service_validate_url"=> '/CAS_PATH/p3/serviceValidate',
+             "logout_url"=> '/CAS_PATH/logout'
+         }
+     }
+   ]
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```
-      - { name: 'cas3',
-          label: 'cas',
-          args: {
-                  url: 'CAS_SERVER',
-                  login_url: '/CAS_PATH/login',
-                  service_validate_url: '/CAS_PATH/p3/serviceValidate',
-                  logout_url: '/CAS_PATH/logout'} }
-    ```
+   ```
+   - { name: 'cas3',
+       label: 'cas',
+       args: {
+               url: 'CAS_SERVER',
+               login_url: '/CAS_PATH/login',
+               service_validate_url: '/CAS_PATH/p3/serviceValidate',
+               logout_url: '/CAS_PATH/logout'} }
+   ```
 
-1.  Change 'CAS_PATH' to the root of your CAS instance (ie. `cas`).
+1. Change 'CAS_PATH' to the root of your CAS instance (ie. `cas`).
 
-1.  If your CAS instance does not use default TGC lifetimes, update the `cas3.session_duration` to at least the current TGC maximum lifetime. To explicitly disable SLO, regardless of CAS settings, set this to 0.
+1. If your CAS instance does not use default TGC lifetimes, update the `cas3.session_duration` to at least the current TGC maximum lifetime. To explicitly disable SLO, regardless of CAS settings, set this to 0.
 
-1.  Save the configuration file.
+1. Save the configuration file.
 
-1.  [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be a CAS tab in the sign in form.
 
diff --git a/doc/integration/elasticsearch.md b/doc/integration/elasticsearch.md
index da1df07a75d..fff06254da7 100644
--- a/doc/integration/elasticsearch.md
+++ b/doc/integration/elasticsearch.md
@@ -12,6 +12,7 @@ special searches:
 - [Advanced Syntax Search](../user/search/advanced_search_syntax.md)
 
 ## Version Requirements
+
 <!-- Please remember to update ee/lib/system_check/app/elasticsearch_check.rb if this changes -->
 
 | GitLab version | Elasticsearch version |
@@ -424,91 +425,90 @@ Here are some common pitfalls and how to overcome them:
 
 - **How can I verify my GitLab instance is using Elasticsearch?**
 
-    The easiest method is via the rails console (`sudo gitlab-rails console`) by running the following:
+  The easiest method is via the rails console (`sudo gitlab-rails console`) by running the following:
 
-    ```ruby
-    u = User.find_by_username('your-username')
-    s = SearchService.new(u, {:search => 'search_term'})
-    pp s.search_objects.class.name
-    ```
+  ```ruby
+  u = User.find_by_username('your-username')
+  s = SearchService.new(u, {:search => 'search_term'})
+  pp s.search_objects.class.name
+  ```
 
-    If you see `Elasticsearch::Model::Response::Records`, you are using Elasticsearch.
+  If you see `Elasticsearch::Model::Response::Records`, you are using Elasticsearch.
 
 - **I updated GitLab and now I can't find anything**
 
-    We continuously make updates to our indexing strategies and aim to support
-    newer versions of Elasticsearch. When indexing changes are made, it may
-    be necessary for you to [reindex](#adding-gitlabs-data-to-the-elasticsearch-index) after updating GitLab.
+  We continuously make updates to our indexing strategies and aim to support
+  newer versions of Elasticsearch. When indexing changes are made, it may
+  be necessary for you to [reindex](#adding-gitlabs-data-to-the-elasticsearch-index) after updating GitLab.
 
 - **I indexed all the repositories but I can't find anything**
 
-    Make sure you indexed all the database data [as stated above](#adding-gitlabs-data-to-the-elasticsearch-index).
+  Make sure you indexed all the database data [as stated above](#adding-gitlabs-data-to-the-elasticsearch-index).
 
-    Beyond that, check via the [Elasticsearch Search API](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html) to see if the data shows up on the Elasticsearch side.
+  Beyond that, check via the [Elasticsearch Search API](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html) to see if the data shows up on the Elasticsearch side.
 
-    If it shows up via the [Elasticsearch Search API](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html), check that it shows up via the rails console (`sudo gitlab-rails console`):
+  If it shows up via the [Elasticsearch Search API](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html), check that it shows up via the rails console (`sudo gitlab-rails console`):
 
-    ```ruby
-    u = User.find_by_username('your-username')
-    s = SearchService.new(u, {:search => 'search_term', :scope => ‘blobs’})
-    pp s.search_objects.to_a
-    ```
+  ```ruby
+  u = User.find_by_username('your-username')
+  s = SearchService.new(u, {:search => 'search_term', :scope => ‘blobs’})
+  pp s.search_objects.to_a
+  ```
 
-    See [Elasticsearch Index Scopes](elasticsearch.md#elasticsearch-index-scopes) for more information on searching for specific types of data.
+  See [Elasticsearch Index Scopes](elasticsearch.md#elasticsearch-index-scopes) for more information on searching for specific types of data.
 
 - **I indexed all the repositories but then switched Elasticsearch servers and now I can't find anything**
 
-    You will need to re-run all the rake tasks to re-index the database, repositories, and wikis.
+  You will need to re-run all the rake tasks to re-index the database, repositories, and wikis.
 
 - **The indexing process is taking a very long time**
 
-    The more data present in your GitLab instance, the longer the indexing process takes.
+  The more data present in your GitLab instance, the longer the indexing process takes.
 
 - **No new data is added to the Elasticsearch index when I push code**
 
-    When performing the initial indexing of blobs, we lock all projects until the project finishes indexing. It could
-    happen that an error during the process causes one or multiple projects to remain locked. In order to unlock them,
-    run the `gitlab:elastic:clear_locked_projects` rake task.
+  When performing the initial indexing of blobs, we lock all projects until the project finishes indexing. It could
+  happen that an error during the process causes one or multiple projects to remain locked. In order to unlock them,
+  run the `gitlab:elastic:clear_locked_projects` rake task.
 
 - **"Can't specify parent if no parent field has been configured"**
 
-    If you enabled Elasticsearch before GitLab 8.12 and have not rebuilt indexes you will get
-    exception in lots of different cases:
-
-    ```text
-    Elasticsearch::Transport::Transport::Errors::BadRequest([400] {
-        "error": {
-            "root_cause": [{
-                "type": "illegal_argument_exception",
-                "reason": "Can't specify parent if no parent field has been configured"
-            }],
-            "type": "illegal_argument_exception",
-            "reason": "Can't specify parent if no parent field has been configured"
-        },
-        "status": 400
-    }):
-    ```
-
-    This is because we changed the index mapping in GitLab 8.12 and the old indexes should be removed and built from scratch again,
-    see details in the [8-11-to-8-12 update guide](https://gitlab.com/gitlab-org/gitlab-ee/blob/master/doc/update/8.11-to-8.12.md#11-elasticsearch-index-update-if-you-currently-use-elasticsearch).
+  If you enabled Elasticsearch before GitLab 8.12 and have not rebuilt indexes you will get
+  exception in lots of different cases:
+
+  ```text
+  Elasticsearch::Transport::Transport::Errors::BadRequest([400] {
+      "error": {
+          "root_cause": [{
+              "type": "illegal_argument_exception",
+              "reason": "Can't specify parent if no parent field has been configured"
+          }],
+          "type": "illegal_argument_exception",
+          "reason": "Can't specify parent if no parent field has been configured"
+      },
+      "status": 400
+  }):
+  ```
+
+  This is because we changed the index mapping in GitLab 8.12 and the old indexes should be removed and built from scratch again,
+  see details in the [8-11-to-8-12 update guide](https://gitlab.com/gitlab-org/gitlab-ee/blob/master/doc/update/8.11-to-8.12.md#11-elasticsearch-index-update-if-you-currently-use-elasticsearch).
 
 - Exception `Elasticsearch::Transport::Transport::Errors::BadRequest`
 
-    If you have this exception (just like in the case above but the actual message is different) please check if you have the correct Elasticsearch version and you met the other [requirements](#system-requirements).
-    There is also an easy way to check it automatically with `sudo gitlab-rake gitlab:check` command.
+  If you have this exception (just like in the case above but the actual message is different) please check if you have the correct Elasticsearch version and you met the other [requirements](#system-requirements).
+  There is also an easy way to check it automatically with `sudo gitlab-rake gitlab:check` command.
 
 - Exception `Elasticsearch::Transport::Transport::Errors::RequestEntityTooLarge`
 
-    ```text
-    [413] {"Message":"Request size exceeded 10485760 bytes"}
-    ```
-
-    This exception is seen when your Elasticsearch cluster is configured to reject
-    requests above a certain size (10MiB in this case). This corresponds to the
-    `http.max_content_length` setting in `elasticsearch.yml`. Increase it to a
-    larger size and restart your Elasticsearch cluster.
+  ```text
+  [413] {"Message":"Request size exceeded 10485760 bytes"}
+  ```
 
-    AWS has [fixed limits](http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/aes-limits.html)
-    for this setting ("Maximum Size of HTTP Request Payloads"), based on the size of
-    the underlying instance.
+  This exception is seen when your Elasticsearch cluster is configured to reject
+  requests above a certain size (10MiB in this case). This corresponds to the
+  `http.max_content_length` setting in `elasticsearch.yml`. Increase it to a
+  larger size and restart your Elasticsearch cluster.
 
+  AWS has [fixed limits](http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/aes-limits.html)
+  for this setting ("Maximum Size of HTTP Request Payloads"), based on the size of
+  the underlying instance.
diff --git a/doc/integration/facebook.md b/doc/integration/facebook.md
index fe789a80eed..837434da737 100644
--- a/doc/integration/facebook.md
+++ b/doc/integration/facebook.md
@@ -2,7 +2,7 @@
 
 To enable the Facebook OmniAuth provider you must register your application with Facebook. Facebook will generate an app ID and secret key for you to use.
 
-1.  Sign in to the [Facebook Developer Platform](https://developers.facebook.com/).
+1. Sign in to the [Facebook Developer Platform](https://developers.facebook.com/).
 
 1. Choose "My Apps" &gt; "Add a New App"
 
@@ -47,53 +47,53 @@ To enable the Facebook OmniAuth provider you must register your application with
 
     ![Facebook API Keys](img/facebook_api_keys.png)
 
-1.  On your GitLab server, open the configuration file.
+1. On your GitLab server, open the configuration file.
 
-    For omnibus package:
+   For omnibus package:
 
-    ```sh
-    sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-    cd /home/git/gitlab
+   ```sh
+   cd /home/git/gitlab
 
-    sudo -u git -H editor config/gitlab.yml
-    ```
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 
-1.  Add the provider configuration:
+1. Add the provider configuration:
 
-    For omnibus package:
+   For omnibus package:
 
-    ```ruby
-    gitlab_rails['omniauth_providers'] = [
-      {
-        "name" => "facebook",
-        "app_id" => "YOUR_APP_ID",
-        "app_secret" => "YOUR_APP_SECRET"
-      }
-    ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "facebook",
+       "app_id" => "YOUR_APP_ID",
+       "app_secret" => "YOUR_APP_SECRET"
+     }
+   ]
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```
-    - { name: 'facebook', app_id: 'YOUR_APP_ID',
-      app_secret: 'YOUR_APP_SECRET' }
-    ```
+   ```
+   - { name: 'facebook', app_id: 'YOUR_APP_ID',
+     app_secret: 'YOUR_APP_SECRET' }
+   ```
 
-1.  Change 'YOUR_APP_ID' to the API key from Facebook page in step 10.
+1. Change 'YOUR_APP_ID' to the API key from Facebook page in step 10.
 
-1.  Change 'YOUR_APP_SECRET' to the API secret from the Facebook page in step 10.
+1. Change 'YOUR_APP_SECRET' to the API secret from the Facebook page in step 10.
 
-1.  Save the configuration file.
+1. Save the configuration file.
 
-1.  [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be a Facebook icon below the regular sign in form. Click the icon to begin the authentication process. Facebook will ask the user to sign in and authorize the GitLab application. If everything goes well the user will be returned to GitLab and will be signed in.
 
diff --git a/doc/integration/github.md b/doc/integration/github.md
index 5b01dd9feb7..c8dbae65465 100644
--- a/doc/integration/github.md
+++ b/doc/integration/github.md
@@ -7,111 +7,111 @@ You can integrate your GitLab instance with GitHub.com as well as GitHub Enterpr
 To enable GitHub OmniAuth provider, you must use GitHub's credentials for your GitLab instance.
 To get the credentials (a pair of Client ID and Client Secret), you must register an application as an OAuth App on GitHub.
 
-1.  Sign in to GitHub.
+1. Sign in to GitHub.
 
-1.  Navigate to your individual user or organization settings, depending on how you want the application registered. It does not matter if the application is registered as an individual or an organization - that is entirely up to you.
+1. Navigate to your individual user or organization settings, depending on how you want the application registered. It does not matter if the application is registered as an individual or an organization - that is entirely up to you.
 
-    - For individual accounts, select **Developer settings** from the left menu, then select **OAuth Apps**.
-    - For organization accounts, directly select **OAuth Apps** from the left menu.
+   - For individual accounts, select **Developer settings** from the left menu, then select **OAuth Apps**.
+   - For organization accounts, directly select **OAuth Apps** from the left menu.
 
-1.  Select **Register an application** (if you don't have any OAuth App) or **New OAuth App** (if you already have OAuth Apps).
-    ![Register OAuth App](img/github_app_entry.png)
+1. Select **Register an application** (if you don't have any OAuth App) or **New OAuth App** (if you already have OAuth Apps).
+   ![Register OAuth App](img/github_app_entry.png)
 
-1.  Provide the required details.
-    - Application name: This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive.
-    - Homepage URL: The URL of your GitLab installation. For example, `https://gitlab.example.com`.
-    - Application description: Fill this in if you wish.
-    - Authorization callback URL: `http(s)://${YOUR_DOMAIN}/users/auth`. Please make sure the port is included if your GitLab instance is not configured on default port.
-    ![Register OAuth App](img/github_register_app.png)
+1. Provide the required details.
+   - Application name: This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive.
+   - Homepage URL: The URL of your GitLab installation. For example, `https://gitlab.example.com`.
+   - Application description: Fill this in if you wish.
+   - Authorization callback URL: `http(s)://${YOUR_DOMAIN}/users/auth`. Please make sure the port is included if your GitLab instance is not configured on default port.
+   ![Register OAuth App](img/github_register_app.png)
 
-    NOTE: Be sure to append `/users/auth` to the end of the callback URL
-    to prevent a [OAuth2 convert
-    redirect](http://tetraph.com/covert_redirect/) vulnerability.
+   NOTE: Be sure to append `/users/auth` to the end of the callback URL
+   to prevent a [OAuth2 convert
+   redirect](http://tetraph.com/covert_redirect/) vulnerability.
 
-1.  Select **Register application**.
+1. Select **Register application**.
 
-1.  You should now see a pair of **Client ID** and **Client Secret** near the top right of the page (see screenshot).
-    Keep this page open as you continue configuration.
-    ![GitHub app](img/github_app.png)
+1. You should now see a pair of **Client ID** and **Client Secret** near the top right of the page (see screenshot).
+   Keep this page open as you continue configuration.
+   ![GitHub app](img/github_app.png)
 
-1.  On your GitLab server, open the configuration file.
+1. On your GitLab server, open the configuration file.
 
-    For omnibus package:
+   For omnibus package:
 
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-      cd /home/git/gitlab
+   ```sh
+   cd /home/git/gitlab
 
-      sudo -u git -H editor config/gitlab.yml
-    ```
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 
-1.  Add the provider configuration:
+1. Add the provider configuration:
 
-    For omnibus package:
+   For omnibus package:
 
-    For GitHub.com:
+   For GitHub.com:
 
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "github",
-          "app_id" => "YOUR_APP_ID",
-          "app_secret" => "YOUR_APP_SECRET",
-          "args" => { "scope" => "user:email" }
-        }
-      ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "github",
+       "app_id" => "YOUR_APP_ID",
+       "app_secret" => "YOUR_APP_SECRET",
+       "args" => { "scope" => "user:email" }
+     }
+   ]
+   ```
 
-    For GitHub Enterprise:
+   For GitHub Enterprise:
 
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "github",
-          "app_id" => "YOUR_APP_ID",
-          "app_secret" => "YOUR_APP_SECRET",
-          "url" => "https://github.example.com/",
-          "args" => { "scope" => "user:email" }
-        }
-      ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "github",
+       "app_id" => "YOUR_APP_ID",
+       "app_secret" => "YOUR_APP_SECRET",
+       "url" => "https://github.example.com/",
+       "args" => { "scope" => "user:email" }
+     }
+   ]
+   ```
 
-    For installation from source:
+   For installation from source:
 
-    For GitHub.com:
+   For GitHub.com:
 
-    ```
-      - { name: 'github', app_id: 'YOUR_APP_ID',
-        app_secret: 'YOUR_APP_SECRET',
-        args: { scope: 'user:email' } }
-    ```
+   ```
+   - { name: 'github', app_id: 'YOUR_APP_ID',
+     app_secret: 'YOUR_APP_SECRET',
+     args: { scope: 'user:email' } }
+   ```
 
-    For GitHub Enterprise:
+   For GitHub Enterprise:
 
-    ```
-      - { name: 'github', app_id: 'YOUR_APP_ID',
-        app_secret: 'YOUR_APP_SECRET',
-        url: "https://github.example.com/",
-        args: { scope: 'user:email' } }
-    ```
+   ```
+   - { name: 'github', app_id: 'YOUR_APP_ID',
+     app_secret: 'YOUR_APP_SECRET',
+     url: "https://github.example.com/",
+     args: { scope: 'user:email' } }
+   ```
 
-    __Replace `https://github.example.com/` with your GitHub URL.__
+   __Replace `https://github.example.com/` with your GitHub URL.__
 
-1.  Change `YOUR_APP_ID` to the Client ID from the GitHub application page from step 6.
+1. Change `YOUR_APP_ID` to the Client ID from the GitHub application page from step 6.
 
-1.  Change `YOUR_APP_SECRET` to the Client Secret from the GitHub application page from step 6.
+1. Change `YOUR_APP_SECRET` to the Client Secret from the GitHub application page from step 6.
 
-1.  Save the configuration file.
+1. Save the configuration file.
 
-1.  [Reconfigure GitLab][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. [Reconfigure GitLab][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be a GitHub icon below the regular sign in form.
 Click the icon to begin the authentication process. GitHub will ask the user to sign in and authorize the GitLab application.
@@ -127,16 +127,16 @@ and changing the global Git `sslVerify` option to `false` in the GitLab server.
 For omnibus package:
 
 ```ruby
-  gitlab_rails['omniauth_providers'] = [
-    {
-      "name" => "github",
-      "app_id" => "YOUR_APP_ID",
-      "app_secret" => "YOUR_APP_SECRET",
-      "url" => "https://github.example.com/",
-      "verify_ssl" => false,
-      "args" => { "scope" => "user:email" }
-    }
-  ]
+gitlab_rails['omniauth_providers'] = [
+  {
+    "name" => "github",
+    "app_id" => "YOUR_APP_ID",
+    "app_secret" => "YOUR_APP_SECRET",
+    "url" => "https://github.example.com/",
+    "verify_ssl" => false,
+    "args" => { "scope" => "user:email" }
+  }
+]
 ```
 
 You will also need to disable Git SSL verification on the server hosting GitLab.
@@ -148,11 +148,11 @@ omnibus_gitconfig['system'] = { "http" => ["sslVerify = false"] }
 For installation from source:
 
 ```
-  - { name: 'github', app_id: 'YOUR_APP_ID',
-    app_secret: 'YOUR_APP_SECRET',
-    url: "https://github.example.com/",
-    verify_ssl: false,
-    args: { scope: 'user:email' } }
+- { name: 'github', app_id: 'YOUR_APP_ID',
+  app_secret: 'YOUR_APP_SECRET',
+  url: "https://github.example.com/",
+  verify_ssl: false,
+  args: { scope: 'user:email' } }
 ```
 
 You will also need to disable Git SSL verification on the server hosting GitLab.
diff --git a/doc/integration/gitlab.md b/doc/integration/gitlab.md
index 70087576678..46da3d88d90 100644
--- a/doc/integration/gitlab.md
+++ b/doc/integration/gitlab.md
@@ -5,78 +5,78 @@ Import projects from GitLab.com and login to your GitLab instance with your GitL
 To enable the GitLab.com OmniAuth provider you must register your application with GitLab.com.
 GitLab.com will generate an application ID and secret key for you to use.
 
-1.  Sign in to GitLab.com
+1. Sign in to GitLab.com
 
 1. On the upper right corner, click on your avatar and go to your **Settings**.
 
-1.  Select **Applications** in the left menu.
+1. Select **Applications** in the left menu.
 
-1.  Provide the required details for **Add new application**.
-    - Name: This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive.
-    - Redirect URI:
+1. Provide the required details for **Add new application**.
+   - Name: This can be anything. Consider something like `<Organization>'s GitLab` or `<Your Name>'s GitLab` or something else descriptive.
+   - Redirect URI:
 
-    ```
-    http://your-gitlab.example.com/import/gitlab/callback
-    http://your-gitlab.example.com/users/auth/gitlab/callback
-    ```
+   ```
+   http://your-gitlab.example.com/import/gitlab/callback
+   http://your-gitlab.example.com/users/auth/gitlab/callback
+   ```
 
-    The first link is required for the importer and second for the authorization.
+   The first link is required for the importer and second for the authorization.
 
-1.  Select **Save application**.
+1. Select **Save application**.
 
-1.  You should now see a **Application Id** and **Secret** near the top right of the page (see screenshot).
-    Keep this page open as you continue configuration.
-    ![GitLab app](img/gitlab_app.png)
+1. You should now see a **Application Id** and **Secret** near the top right of the page (see screenshot).
+   Keep this page open as you continue configuration.
+   ![GitLab app](img/gitlab_app.png)
 
-1.  On your GitLab server, open the configuration file.
+1. On your GitLab server, open the configuration file.
 
-    For omnibus package:
+   For omnibus package:
 
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-      cd /home/git/gitlab
+   ```sh
+   cd /home/git/gitlab
 
-      sudo -u git -H editor config/gitlab.yml
-    ```
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 
-1.  Add the provider configuration:
+1. Add the provider configuration:
 
-    For omnibus package:
+   For omnibus package:
 
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "gitlab",
-          "app_id" => "YOUR_APP_ID",
-          "app_secret" => "YOUR_APP_SECRET",
-          "args" => { "scope" => "api" }
-        }
-      ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "gitlab",
+       "app_id" => "YOUR_APP_ID",
+       "app_secret" => "YOUR_APP_SECRET",
+       "args" => { "scope" => "api" }
+     }
+   ]
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```
-      - { name: 'gitlab', app_id: 'YOUR_APP_ID',
-        app_secret: 'YOUR_APP_SECRET',
-        args: { scope: 'api' } }
-    ```
+   ```
+   - { name: 'gitlab', app_id: 'YOUR_APP_ID',
+     app_secret: 'YOUR_APP_SECRET',
+     args: { scope: 'api' } }
+   ```
 
-1.  Change 'YOUR_APP_ID' to the Application ID from the GitLab.com application page.
+1. Change 'YOUR_APP_ID' to the Application ID from the GitLab.com application page.
 
-1.  Change 'YOUR_APP_SECRET' to the secret from the GitLab.com application page.
+1. Change 'YOUR_APP_SECRET' to the secret from the GitLab.com application page.
 
-1.  Save the configuration file.
+1. Save the configuration file.
 
-1.  [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be a GitLab.com icon below the regular sign in form.
 Click the icon to begin the authentication process. GitLab.com will ask the user to sign in and authorize the GitLab application.
diff --git a/doc/integration/google.md b/doc/integration/google.md
index d2b4e119978..4f6999571b6 100644
--- a/doc/integration/google.md
+++ b/doc/integration/google.md
@@ -10,10 +10,10 @@ In Google's side:
 1. Navigate to the [cloud resource manager](https://console.cloud.google.com/cloud-resource-manager) page
 1. Select **Create Project**
 1. Provide the project information:
-    - **Project name** - "GitLab" works just fine here.
-    - **Project ID** - Must be unique to all Google Developer registered applications.
-      Google provides a randomly generated Project ID by default. You can use
-      the randomly generated ID or choose a new one.
+   - **Project name** - "GitLab" works just fine here.
+   - **Project ID** - Must be unique to all Google Developer registered applications.
+     Google provides a randomly generated Project ID by default. You can use
+     the randomly generated ID or choose a new one.
 1. Refresh the page and you should see your new project in the list
 1. Go to the [Google API Console](https://console.developers.google.com/apis/dashboard)
 1. Select the previously created project form the upper left corner
@@ -21,17 +21,17 @@ In Google's side:
 1. Select **OAuth consent screen** and fill the form with the required information
 1. In the **Credentials** tab, select **Create credentials > OAuth client ID**
 1. Fill in the required information
-    - **Application type** - Choose "Web Application"
-    - **Name** - Use the default one or provide your own
-    - **Authorized JavaScript origins** -This isn't really used by GitLab but go
-      ahead and put `https://gitlab.example.com`
-    - **Authorized redirect URIs** - Enter your domain name followed by the
-      callback URIs one at a time:
-
-        ```
-        https://gitlab.example.com/users/auth/google_oauth2/callback
-        https://gitlab.example.com/-/google_api/auth/callback
-        ```
+   - **Application type** - Choose "Web Application"
+   - **Name** - Use the default one or provide your own
+   - **Authorized JavaScript origins** -This isn't really used by GitLab but go
+     ahead and put `https://gitlab.example.com`
+   - **Authorized redirect URIs** - Enter your domain name followed by the
+     callback URIs one at a time:
+
+     ```
+     https://gitlab.example.com/users/auth/google_oauth2/callback
+     https://gitlab.example.com/-/google_api/auth/callback
+     ```
 
 1. You should now be able to see a Client ID and Client secret. Note them down
    or keep this page open as you will need them later.
@@ -45,64 +45,64 @@ On your GitLab server:
 
 1. Open the configuration file.
 
-    For Omnibus GitLab:
+   For Omnibus GitLab:
 
-    ```sh
-    sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-    cd /home/git/gitlab
-    sudo -u git -H editor config/gitlab.yml
-    ```
+   ```sh
+   cd /home/git/gitlab
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
 1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 1. Add the provider configuration:
 
-    For Omnibus GitLab:
+   For Omnibus GitLab:
 
-    ```ruby
-    gitlab_rails['omniauth_providers'] = [
-      {
-        "name" => "google_oauth2",
-        "app_id" => "YOUR_APP_ID",
-        "app_secret" => "YOUR_APP_SECRET",
-        "args" => { "access_type" => "offline", "approval_prompt" => '' }
-      }
-    ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "google_oauth2",
+       "app_id" => "YOUR_APP_ID",
+       "app_secret" => "YOUR_APP_SECRET",
+       "args" => { "access_type" => "offline", "approval_prompt" => '' }
+     }
+   ]
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```yaml
-    - { name: 'google_oauth2', app_id: 'YOUR_APP_ID',
-      app_secret: 'YOUR_APP_SECRET',
-      args: { access_type: 'offline', approval_prompt: '' } }
-    ```
+   ```yaml
+   - { name: 'google_oauth2', app_id: 'YOUR_APP_ID',
+     app_secret: 'YOUR_APP_SECRET',
+     args: { access_type: 'offline', approval_prompt: '' } }
+   ```
 
 1. Change `YOUR_APP_ID` to the client ID from the Google Developer page
 1. Similarly, change `YOUR_APP_SECRET` to the client secret
 1. Make sure that you configure GitLab to use an FQDN as Google will not accept
    raw IP addresses.
 
-    For Omnibus packages:
+   For Omnibus packages:
 
-    ```ruby
-    external_url 'https://gitlab.example.com'
-    ```
+   ```ruby
+   external_url 'https://gitlab.example.com'
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```yaml
-    gitlab:
-      host: https://gitlab.example.com
-    ```
+   ```yaml
+   gitlab:
+     host: https://gitlab.example.com
+   ```
 
-1.  Save the configuration file.
-1.  [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. Save the configuration file.
+1. [Reconfigure][] or [restart GitLab][] for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page there should now be a Google icon below the regular sign in
 form. Click the icon to begin the authentication process. Google will ask the
diff --git a/doc/integration/kerberos.md b/doc/integration/kerberos.md
index cf2ef511264..b4f2025265e 100644
--- a/doc/integration/kerberos.md
+++ b/doc/integration/kerberos.md
@@ -50,20 +50,20 @@ For source installations, make sure the `kerberos` gem group
    authentication. In most cases, you only need to enable Kerberos and specify
    the location of the keytab:
 
-    ```yaml
-    omniauth:
-      enabled: true
-      allow_single_sign_on: ['kerberos']
+   ```yaml
+   omniauth:
+     enabled: true
+     allow_single_sign_on: ['kerberos']
 
-    kerberos:
-      # Allow the HTTP Negotiate authentication method for Git clients
-      enabled: true
+   kerberos:
+     # Allow the HTTP Negotiate authentication method for Git clients
+     enabled: true
 
-      # Kerberos 5 keytab file. The keytab file must be readable by the GitLab user,
-      # and should be different from other keytabs in the system.
-      # (default: use default keytab from Krb5 config)
-      keytab: /etc/http.keytab
-    ```
+     # Kerberos 5 keytab file. The keytab file must be readable by the GitLab user,
+     # and should be different from other keytabs in the system.
+     # (default: use default keytab from Krb5 config)
+     keytab: /etc/http.keytab
+   ```
 
 1. [Restart GitLab] for the changes to take effect.
 
@@ -73,13 +73,13 @@ For source installations, make sure the `kerberos` gem group
 
 1. Edit `/etc/gitlab/gitlab.rb`:
 
-    ```ruby
-    gitlab_rails['omniauth_enabled'] = true
-    gitlab_rails['omniauth_allow_single_sign_on'] = ['kerberos']
+   ```ruby
+   gitlab_rails['omniauth_enabled'] = true
+   gitlab_rails['omniauth_allow_single_sign_on'] = ['kerberos']
 
-    gitlab_rails['kerberos_enabled'] = true
-    gitlab_rails['kerberos_keytab'] = "/etc/http.keytab"
-    ```
+   gitlab_rails['kerberos_enabled'] = true
+   gitlab_rails['kerberos_keytab'] = "/etc/http.keytab"
+   ```
 
 1. [Reconfigure GitLab] for the changes to take effect.
 
@@ -149,26 +149,26 @@ keep offering only `basic` authentication.
    (e.g., `/etc/nginx/sites-available/gitlab-ssl`) and configure NGINX to
    listen to port `8443` in addition to the standard HTTPS port:
 
-    ```conf
-    server {
-      listen 0.0.0.0:443 ssl;
-      listen [::]:443 ipv6only=on ssl default_server;
-      listen 0.0.0.0:8443 ssl;
-      listen [::]:8443 ipv6only=on ssl;
-    ```
+   ```conf
+   server {
+     listen 0.0.0.0:443 ssl;
+     listen [::]:443 ipv6only=on ssl default_server;
+     listen 0.0.0.0:8443 ssl;
+     listen [::]:8443 ipv6only=on ssl;
+   ```
 
 1. Update the Kerberos section of [gitlab.yml]:
 
-    ```yaml
-    kerberos:
-      # Dedicated port: Git before 2.4 does not fall back to Basic authentication if Negotiate fails.
-      # To support both Basic and Negotiate methods with older versions of Git, configure
-      # nginx to proxy GitLab on an extra port (e.g. 8443) and uncomment the following lines
-      # to dedicate this port to Kerberos authentication. (default: false)
-      use_dedicated_port: true
-      port: 8443
-      https: true
-    ```
+   ```yaml
+   kerberos:
+     # Dedicated port: Git before 2.4 does not fall back to Basic authentication if Negotiate fails.
+     # To support both Basic and Negotiate methods with older versions of Git, configure
+     # nginx to proxy GitLab on an extra port (e.g. 8443) and uncomment the following lines
+     # to dedicate this port to Kerberos authentication. (default: false)
+     use_dedicated_port: true
+     port: 8443
+     https: true
+   ```
 
 1. [Restart GitLab] and NGINX for the changes to take effect.
 
@@ -178,11 +178,11 @@ keep offering only `basic` authentication.
 
 1. Edit `/etc/gitlab/gitlab.rb`:
 
-    ```ruby
-    gitlab_rails['kerberos_use_dedicated_port'] = true
-    gitlab_rails['kerberos_port'] = 8443
-    gitlab_rails['kerberos_https'] = true
-    ```
+   ```ruby
+   gitlab_rails['kerberos_use_dedicated_port'] = true
+   gitlab_rails['kerberos_port'] = 8443
+   gitlab_rails['kerberos_https'] = true
+   ```
 
 1. [Reconfigure GitLab] for the changes to take effect.
 
@@ -214,12 +214,12 @@ remove the OmniAuth provider named `kerberos` from your `gitlab.yml` /
 1. Edit [gitlab.yml] and remove the `- { name: 'kerberos' }` line under omniauth
    providers:
 
-    ```yaml
-    omniauth:
-      # ...
-      providers:
-        - { name: 'kerberos' } # <-- remove this line
-    ```
+   ```yaml
+   omniauth:
+     # ...
+     providers:
+       - { name: 'kerberos' } # <-- remove this line
+   ```
 
 1. [Restart GitLab] for the changes to take effect.
 
@@ -230,11 +230,11 @@ remove the OmniAuth provider named `kerberos` from your `gitlab.yml` /
 1. Edit `/etc/gitlab/gitlab.rb` and remove the `{ "name" => "kerberos" }` line
    under `gitlab_rails['omniauth_providers']`:
 
-    ```ruby
-    gitlab_rails['omniauth_providers'] = [
-      { "name" => "kerberos" } # <-- remove this entry
-    ]
-    ```
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     { "name" => "kerberos" } # <-- remove this entry
+   ]
+   ```
 
 1. [Reconfigure GitLab] for the changes to take effect.
 
@@ -290,7 +290,7 @@ remote: HTTP Basic: Access denied
 fatal: Authentication failed for '<KRB5 path>'
 ```
 
-If you are using Git v2.11 or newer and see the above error when cloning, you can 
+If you are using Git v2.11 or newer and see the above error when cloning, you can
 set the `http.emptyAuth` Git option to `true` to fix this:
 
 ```
diff --git a/doc/integration/oauth2_generic.md b/doc/integration/oauth2_generic.md
index 3c1a0f2a117..f4119b1d1ce 100644
--- a/doc/integration/oauth2_generic.md
+++ b/doc/integration/oauth2_generic.md
@@ -24,11 +24,11 @@ This strategy is designed to allow configuration of the simple OmniAuth SSO proc
 
 1. Register your application in the OAuth2 provider you wish to authenticate with.
 
-    The redirect URI you provide when registering the application should be:
+   The redirect URI you provide when registering the application should be:
 
-    ```
-    http://your-gitlab.host.com/users/auth/oauth2_generic/callback
-    ```
+   ```
+   http://your-gitlab.host.com/users/auth/oauth2_generic/callback
+   ```
 
 1. You should now be able to get a Client ID and Client Secret.
    Where this shows up will differ for each provider.
@@ -36,18 +36,18 @@ This strategy is designed to allow configuration of the simple OmniAuth SSO proc
 
 1. On your GitLab server, open the configuration file.
 
-    For Omnibus package:
+   For Omnibus package:
 
-    ```sh
-    sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For installations from source:
+   For installations from source:
 
-    ```sh
-    cd /home/git/gitlab
-    sudo -u git -H editor config/gitlab.yml
-    ```
+   ```sh
+   cd /home/git/gitlab
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
 1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings
 
diff --git a/doc/integration/omniauth.md b/doc/integration/omniauth.md
index bf5debc7694..7a92ed994c7 100644
--- a/doc/integration/omniauth.md
+++ b/doc/integration/omniauth.md
@@ -71,57 +71,57 @@ To change these settings:
 
 - **For omnibus package**
 
-    Open the configuration file:
+  Open the configuration file:
 
-    ```sh
-    sudo editor /etc/gitlab/gitlab.rb
-    ```
+  ```sh
+  sudo editor /etc/gitlab/gitlab.rb
+  ```
 
-    and change:
+  and change:
 
-    ```ruby
-    # Versions prior to 11.4 require this to be set to true
-    # gitlab_rails['omniauth_enabled'] = nil
+  ```ruby
+  # Versions prior to 11.4 require this to be set to true
+  # gitlab_rails['omniauth_enabled'] = nil
 
-    # CAUTION!
-    # This allows users to login without having a user account first. Define the allowed providers
-    # using an array, e.g. ["saml", "twitter"], or as true/false to allow all providers or none.
-    # User accounts will be created automatically when authentication was successful.
-    gitlab_rails['omniauth_allow_single_sign_on'] = ['saml', 'twitter']
-    gitlab_rails['omniauth_auto_link_ldap_user'] = true
-    gitlab_rails['omniauth_block_auto_created_users'] = true
-    ```
+  # CAUTION!
+  # This allows users to login without having a user account first. Define the allowed providers
+  # using an array, e.g. ["saml", "twitter"], or as true/false to allow all providers or none.
+  # User accounts will be created automatically when authentication was successful.
+  gitlab_rails['omniauth_allow_single_sign_on'] = ['saml', 'twitter']
+  gitlab_rails['omniauth_auto_link_ldap_user'] = true
+  gitlab_rails['omniauth_block_auto_created_users'] = true
+  ```
 
 - **For installations from source**
 
-    Open the configuration file:
+  Open the configuration file:
 
-    ```sh
-    cd /home/git/gitlab
+  ```sh
+  cd /home/git/gitlab
 
-    sudo -u git -H editor config/gitlab.yml
-    ```
+  sudo -u git -H editor config/gitlab.yml
+  ```
 
-    and change the following section:
+  and change the following section:
 
-    ```yaml
-     ## OmniAuth settings
-      omniauth:
-        # Allow login via Twitter, Google, etc. using OmniAuth providers
-        # Versions prior to 11.4 require this to be set to true
-        # enabled: true
+  ```yaml
+  ## OmniAuth settings
+   omniauth:
+     # Allow login via Twitter, Google, etc. using OmniAuth providers
+     # Versions prior to 11.4 require this to be set to true
+     # enabled: true
 
-        # CAUTION!
-        # This allows users to login without having a user account first. Define the allowed providers
-        # using an array, e.g. ["saml", "twitter"], or as true/false to allow all providers or none.
-        # User accounts will be created automatically when authentication was successful.
-        allow_single_sign_on: ["saml", "twitter"]
+     # CAUTION!
+     # This allows users to login without having a user account first. Define the allowed providers
+     # using an array, e.g. ["saml", "twitter"], or as true/false to allow all providers or none.
+     # User accounts will be created automatically when authentication was successful.
+     allow_single_sign_on: ["saml", "twitter"]
 
-        auto_link_ldap_user: true
+     auto_link_ldap_user: true
 
-        # Locks down those users until they have been cleared by the admin (default: true).
-        block_auto_created_users: true
-    ```
+     # Locks down those users until they have been cleared by the admin (default: true).
+     block_auto_created_users: true
+  ```
 
 Now we can choose one or more of the [Supported Providers](#supported-providers)
 listed above to continue the configuration process.
@@ -161,14 +161,14 @@ want their accounts to be upgraded to full internal accounts.
 **For Omnibus installations**
 
 ```ruby
-  gitlab_rails['omniauth_external_providers'] = ['twitter', 'google_oauth2']
+gitlab_rails['omniauth_external_providers'] = ['twitter', 'google_oauth2']
 ```
 
 **For installations from source**
 
 ```yaml
-  omniauth:
-    external_providers: ['twitter', 'google_oauth2']
+omniauth:
+  external_providers: ['twitter', 'google_oauth2']
 ```
 
 ## Using Custom Omniauth Providers
@@ -186,23 +186,31 @@ these cases you can use the Omniauth provider.
 These steps are fairly general and you will need to figure out the exact details
 from the Omniauth provider's documentation.
 
--   Stop GitLab:
+- Stop GitLab:
 
-        sudo service gitlab stop
+  ```sh
+  sudo service gitlab stop
+  ```
 
--   Add the gem to your [Gemfile](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/Gemfile):
+- Add the gem to your [Gemfile](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/Gemfile):
 
-        gem "omniauth-your-auth-provider"
+  ```sh
+  gem "omniauth-your-auth-provider"
+  ```
 
--   Install the new Omniauth provider gem by running the following command:
+- Install the new Omniauth provider gem by running the following command:
 
-        sudo -u git -H bundle install --without development test mysql --path vendor/bundle --no-deployment
+  ```sh
+  sudo -u git -H bundle install --without development test mysql --path vendor/bundle --no-deployment
+  ```
 
-    > These are the same commands you used during initial installation in the [Install Gems section](../install/installation.md#install-gems) with `--path vendor/bundle --no-deployment` instead of `--deployment`.
+  > These are the same commands you used during initial installation in the [Install Gems section](../install/installation.md#install-gems) with `--path vendor/bundle --no-deployment` instead of `--deployment`.
 
--   Start GitLab:
+- Start GitLab:
 
-        sudo service gitlab start
+  ```sh
+  sudo service gitlab start
+  ```
 
 ### Examples
 
@@ -247,8 +255,8 @@ gitlab_rails['omniauth_enabled'] = false
 **For installations from source**
 
 ```yaml
-  omniauth:
-    enabled: false
+omniauth:
+  enabled: false
 ```
 
 ## Keep OmniAuth user profiles up to date
@@ -258,14 +266,14 @@ You can enable profile syncing from selected OmniAuth providers and for all or f
 When authenticating using LDAP, the user's name and email are always synced.
 
 ```ruby
-  gitlab_rails['sync_profile_from_provider'] = ['twitter', 'google_oauth2']
-  gitlab_rails['sync_profile_attributes'] = ['name', 'email', 'location']
- ```
+gitlab_rails['sync_profile_from_provider'] = ['twitter', 'google_oauth2']
+gitlab_rails['sync_profile_attributes'] = ['name', 'email', 'location']
+```
 
 **For installations from source**
 
 ```yaml
-  omniauth:
-    sync_profile_from_provider: ['twitter', 'google_oauth2']
-    sync_profile_attributes: ['email', 'location']
+omniauth:
+  sync_profile_from_provider: ['twitter', 'google_oauth2']
+  sync_profile_attributes: ['email', 'location']
 ```
diff --git a/doc/integration/salesforce.md b/doc/integration/salesforce.md
index 1ef43cfcece..176622e8050 100644
--- a/doc/integration/salesforce.md
+++ b/doc/integration/salesforce.md
@@ -7,73 +7,77 @@ You can integrate your GitLab instance with [Salesforce](https://www.salesforce.
 To enable Salesforce OmniAuth provider, you must use Salesforce's credentials for your GitLab instance.
 To get the credentials (a pair of Client ID and Client Secret), you must [create a Connected App](https://help.salesforce.com/articleView?id=connected_app_create.htm&type=5) on Salesforce.
 
-1.  Sign in to [Salesforce](https://login.salesforce.com/).
+1. Sign in to [Salesforce](https://login.salesforce.com/).
 
-1.  In Setup, enter `App Manager` in the Quick Find box, click **App Manager**, then click **New Connected App**.
+1. In Setup, enter `App Manager` in the Quick Find box, click **App Manager**, then click **New Connected App**.
 
-1.  Fill in the application details into the following fields:
-    - **Connected App Name** and **API Name**: Set to any value but consider something like `<Organization>'s GitLab`, `<Your Name>'s GitLab`, or something else that is descriptive.
-    - **Contact Email**: Enter the contact email for Salesforce to use when contacting you or your support team.
-    - **Description**: Description for the application.
+1. Fill in the application details into the following fields:
+   - **Connected App Name** and **API Name**: Set to any value but consider something like `<Organization>'s GitLab`, `<Your Name>'s GitLab`, or something else that is descriptive.
+   - **Contact Email**: Enter the contact email for Salesforce to use when contacting you or your support team.
+   - **Description**: Description for the application.
 
-    ![Salesforce App Details](img/salesforce_app_details.png)
-1.  Select **API (Enable OAuth Settings)** and click on **Enable OAuth Settings**.
-1.  Fill in the application details into the following fields:
-    - **Callback URL**: The callback URL of your GitLab installation. For example, `https://gitlab.example.com/users/auth/salesforce/callback`.
-    - **Selected OAuth Scopes**: Move **Access your basic information (id, profile, email, address, phone)** and **Allow access to your unique identifier (openid)** to the right column.
+   ![Salesforce App Details](img/salesforce_app_details.png)
+
+1. Select **API (Enable OAuth Settings)** and click on **Enable OAuth Settings**.
+1. Fill in the application details into the following fields:
+   - **Callback URL**: The callback URL of your GitLab installation. For example, `https://gitlab.example.com/users/auth/salesforce/callback`.
+   - **Selected OAuth Scopes**: Move **Access your basic information (id, profile, email, address, phone)** and **Allow access to your unique identifier (openid)** to the right column.
+
+   ![Salesforce Oauth App Details](img/salesforce_oauth_app_details.png)
 
-    ![Salesforce Oauth App Details](img/salesforce_oauth_app_details.png)
 1. Click **Save**.
 
-1.  On your GitLab server, open the configuration file.
+1. On your GitLab server, open the configuration file.
+
+   For omnibus package:
+
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
 
-    For omnibus package:
+   For installations from source:
 
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
+   ```sh
+   cd /home/git/gitlab
+   sudo -u git -H editor config/gitlab.yml
+   ```
 
-    For installations from source:
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
 
-    ```sh
-      cd /home/git/gitlab
-      sudo -u git -H editor config/gitlab.yml
-    ```
+1. Add the provider configuration:
 
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+   For omnibus package:
 
-1.  Add the provider configuration:
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "salesforce",
+       "app_id" => "SALESFORCE_CLIENT_ID",
+       "app_secret" => "SALESFORCE_CLIENT_SECRET"
+     }
+   ]
+   ```
 
-    For omnibus package:
+   For installation from source:
 
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "salesforce",
-          "app_id" => "SALESFORCE_CLIENT_ID",
-          "app_secret" => "SALESFORCE_CLIENT_SECRET"
-        }
-      ]
-    ```
+   ```
+   - { name: 'salesforce',
+       app_id: 'SALESFORCE_CLIENT_ID',
+       app_secret: 'SALESFORCE_CLIENT_SECRET'
+     }
+   ```
 
-    For installation from source:
+1. Change `SALESFORCE_CLIENT_ID` to the Consumer Key from the Salesforce connected application page.
+1. Change `SALESFORCE_CLIENT_SECRET` to the Consumer Secret from the Salesforce connected application page.
 
-    ```
-      - { name: 'salesforce',
-          app_id: 'SALESFORCE_CLIENT_ID',
-          app_secret: 'SALESFORCE_CLIENT_SECRET'
-        }
-    ```
-1.  Change `SALESFORCE_CLIENT_ID` to the Consumer Key from the Salesforce connected application page.
-1.  Change `SALESFORCE_CLIENT_SECRET` to the Consumer Secret from the Salesforce connected application page.
-    ![Salesforce App Secret Details](img/salesforce_app_secret_details.png)
+   ![Salesforce App Secret Details](img/salesforce_app_secret_details.png)
 
-1.  Save the configuration file.
-1.  [Reconfigure GitLab]( ../administration/restart_gitlab.md#omnibus-gitlab-reconfigure ) or [restart GitLab]( ../administration/restart_gitlab.md#installations-from-source ) for the changes to take effect if you installed GitLab via Omnibus or from source respectively.
+1. Save the configuration file.
+1. [Reconfigure GitLab]( ../administration/restart_gitlab.md#omnibus-gitlab-reconfigure ) or [restart GitLab]( ../administration/restart_gitlab.md#installations-from-source ) for the changes to take effect if you installed GitLab via Omnibus or from source respectively.
 
 On the sign in page, there should now be a Salesforce icon below the regular sign in form.
 Click the icon to begin the authentication process. Salesforce will ask the user to sign in and authorize the GitLab application.
 If everything goes well, the user will be returned to GitLab and will be signed in.
 
 NOTE: **Note:**
-GitLab requires the email address of each new user. Once the user is logged in using Salesforce, GitLab will redirect the user to the profile page where they will have to provide the email and verify the email.
\ No newline at end of file
+GitLab requires the email address of each new user. Once the user is logged in using Salesforce, GitLab will redirect the user to the profile page where they will have to provide the email and verify the email.
diff --git a/doc/integration/shibboleth.md b/doc/integration/shibboleth.md
index 07c83c1a049..27355d25266 100644
--- a/doc/integration/shibboleth.md
+++ b/doc/integration/shibboleth.md
@@ -14,35 +14,35 @@ The following changes are needed to enable Shibboleth:
 
 1. Protect omniauth-shibboleth callback URL:
 
-    ```
-      <Location /users/auth/shibboleth/callback>
-        AuthType shibboleth
-        ShibRequestSetting requireSession 1
-        ShibUseHeaders On
-        require valid-user
-      </Location>
-
-      Alias /shibboleth-sp /usr/share/shibboleth
-      <Location /shibboleth-sp>
-        Satisfy any
-      </Location>
-
-      <Location /Shibboleth.sso>
-        SetHandler shib
-      </Location>
-    ```
+   ```
+   <Location /users/auth/shibboleth/callback>
+     AuthType shibboleth
+     ShibRequestSetting requireSession 1
+     ShibUseHeaders On
+     require valid-user
+   </Location>
+
+   Alias /shibboleth-sp /usr/share/shibboleth
+   <Location /shibboleth-sp>
+     Satisfy any
+   </Location>
+
+   <Location /Shibboleth.sso>
+     SetHandler shib
+   </Location>
+   ```
 
 1. Exclude shibboleth URLs from rewriting. Add `RewriteCond %{REQUEST_URI} !/Shibboleth.sso` and `RewriteCond %{REQUEST_URI} !/shibboleth-sp`. Config should look like this:
 
-    ```
-      # Apache equivalent of Nginx try files
-      RewriteEngine on
-      RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
-      RewriteCond %{REQUEST_URI} !/Shibboleth.sso
-      RewriteCond %{REQUEST_URI} !/shibboleth-sp
-      RewriteRule .* http://127.0.0.1:8080%{REQUEST_URI} [P,QSA]
-      RequestHeader set X_FORWARDED_PROTO 'https'
-    ```
+   ```
+   # Apache equivalent of Nginx try files
+   RewriteEngine on
+   RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
+   RewriteCond %{REQUEST_URI} !/Shibboleth.sso
+   RewriteCond %{REQUEST_URI} !/shibboleth-sp
+   RewriteRule .* http://127.0.0.1:8080%{REQUEST_URI} [P,QSA]
+   RequestHeader set X_FORWARDED_PROTO 'https'
+   ```
 
 1. Edit `/etc/gitlab/gitlab.rb` configuration file to enable OmniAuth and add
    Shibboleth as an OmniAuth provider. User attributes will be sent from the
@@ -60,31 +60,31 @@ The following changes are needed to enable Shibboleth:
 
    The file should look like this:
 
-    ```
-    external_url 'https://gitlab.example.com'
-    gitlab_rails['internal_api_url'] = 'https://gitlab.example.com'
-
-    # disable Nginx
-    nginx['enable'] = false
-
-    gitlab_rails['omniauth_allow_single_sign_on'] = true
-    gitlab_rails['omniauth_block_auto_created_users'] = false
-    gitlab_rails['omniauth_enabled'] = true
-    gitlab_rails['omniauth_providers'] = [
-      {
-        "name"  => "'shibboleth"',
-        "label" => "Text for Login Button",
-        "args"  => {
-            "shib_session_id_field"     => "HTTP_SHIB_SESSION_ID",
-            "shib_application_id_field" => "HTTP_SHIB_APPLICATION_ID",
-            "uid_field"                 => 'HTTP_EPPN',
-            "name_field"                => 'HTTP_CN',
-            "info_fields" => { "email" => 'HTTP_MAIL'}
-        }
-      }
-    ]
-
-    ```
+   ```
+   external_url 'https://gitlab.example.com'
+   gitlab_rails['internal_api_url'] = 'https://gitlab.example.com'
+
+   # disable Nginx
+   nginx['enable'] = false
+
+   gitlab_rails['omniauth_allow_single_sign_on'] = true
+   gitlab_rails['omniauth_block_auto_created_users'] = false
+   gitlab_rails['omniauth_enabled'] = true
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name"  => "'shibboleth"',
+       "label" => "Text for Login Button",
+       "args"  => {
+           "shib_session_id_field"     => "HTTP_SHIB_SESSION_ID",
+           "shib_application_id_field" => "HTTP_SHIB_APPLICATION_ID",
+           "uid_field"                 => 'HTTP_EPPN',
+           "name_field"                => 'HTTP_CN',
+           "info_fields" => { "email" => 'HTTP_MAIL'}
+       }
+     }
+   ]
+
+   ```
 
 1. [Reconfigure](../administration/restart_gitlab.md#omnibus-gitlab-reconfigure) or [restart](../administration/restart_gitlab.md#installations-from-source) GitLab for the changes to take effect if you
    installed GitLab via Omnibus or from source respectively.
@@ -97,44 +97,44 @@ The order of the first 2 Location directives is important. If they are reversed,
 you will not get a shibboleth session!
 
 ```
-  <Location />
-    Require all granted
-    ProxyPassReverse http://127.0.0.1:8181
-    ProxyPassReverse http://YOUR_SERVER_FQDN/
-  </Location>
-
-  <Location /users/auth/shibboleth/callback>
-    AuthType shibboleth
-    ShibRequestSetting requireSession 1
-    ShibUseHeaders On
-    Require shib-session
-  </Location>
-
-  Alias /shibboleth-sp /usr/share/shibboleth
-
-  <Location /shibboleth-sp>
-    Require all granted
-  </Location>
-
-  <Location /Shibboleth.sso>
-    SetHandler shib
-  </Location>
-
-  RewriteEngine on
-
-  #Don't escape encoded characters in api requests
-  RewriteCond %{REQUEST_URI} ^/api/v4/.*
-  RewriteCond %{REQUEST_URI} !/Shibboleth.sso
-  RewriteCond %{REQUEST_URI} !/shibboleth-sp
-  RewriteRule .* http://127.0.0.1:8181%{REQUEST_URI} [P,QSA,NE]
-
-  #Forward all requests to gitlab-workhorse except existing files
-  RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f [OR]
-  RewriteCond %{REQUEST_URI} ^/uploads/.*
-  RewriteCond %{REQUEST_URI} !/Shibboleth.sso
-  RewriteCond %{REQUEST_URI} !/shibboleth-sp
-  RewriteRule .* http://127.0.0.1:8181%{REQUEST_URI} [P,QSA]
-
-  RequestHeader set X_FORWARDED_PROTO 'https'
-  RequestHeader set X-Forwarded-Ssl on
+<Location />
+  Require all granted
+  ProxyPassReverse http://127.0.0.1:8181
+  ProxyPassReverse http://YOUR_SERVER_FQDN/
+</Location>
+
+<Location /users/auth/shibboleth/callback>
+  AuthType shibboleth
+  ShibRequestSetting requireSession 1
+  ShibUseHeaders On
+  Require shib-session
+</Location>
+
+Alias /shibboleth-sp /usr/share/shibboleth
+
+<Location /shibboleth-sp>
+  Require all granted
+</Location>
+
+<Location /Shibboleth.sso>
+  SetHandler shib
+</Location>
+
+RewriteEngine on
+
+#Don't escape encoded characters in api requests
+RewriteCond %{REQUEST_URI} ^/api/v4/.*
+RewriteCond %{REQUEST_URI} !/Shibboleth.sso
+RewriteCond %{REQUEST_URI} !/shibboleth-sp
+RewriteRule .* http://127.0.0.1:8181%{REQUEST_URI} [P,QSA,NE]
+
+#Forward all requests to gitlab-workhorse except existing files
+RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f [OR]
+RewriteCond %{REQUEST_URI} ^/uploads/.*
+RewriteCond %{REQUEST_URI} !/Shibboleth.sso
+RewriteCond %{REQUEST_URI} !/shibboleth-sp
+RewriteRule .* http://127.0.0.1:8181%{REQUEST_URI} [P,QSA]
+
+RequestHeader set X_FORWARDED_PROTO 'https'
+RequestHeader set X-Forwarded-Ssl on
 ```
diff --git a/doc/integration/ultra_auth.md b/doc/integration/ultra_auth.md
index 69b2a75050d..9ed1bdb4882 100644
--- a/doc/integration/ultra_auth.md
+++ b/doc/integration/ultra_auth.md
@@ -7,69 +7,78 @@ You can integrate your GitLab instance with [UltraAuth](https://ultraauth.com) t
 To enable UltraAuth OmniAuth provider, you must use UltraAuth's credentials for your GitLab instance.
 To get the credentials (a pair of Client ID and Client Secret), you must register an application on UltraAuth.
 
-1.  Sign in to [UltraAuth](https://ultraauth.com).
-1.  Navigate to [Create an App](https://ultraauth.com/select-strategy) and click on "Ruby on Rails".
-1.  Scroll down the page that is displayed to locate the **Client ID** and **Client Secret**.
-    Keep this page open as you continue configuration.
-    ![UltraAuth Credentials: OPENID_CLIENT_ID and OPENID_CLIENT_SECRET](img/ultra_auth_credentials.png)
-1.  Click on "Edit Callback URL" link.
-    ![Edit UltraAuth Callback URL](img/ultra_auth_edit_callback_url_highlighted.png)
-1.  The callback URL will be `http(s)://<your_domain>/users/auth/ultraauth/callback`
-    ![UltraAuth Callback URL](img/ultra_auth_edit_callback_url.png)
-1.  Select **Register application**.
-1.  On your GitLab server, open the configuration file.
-
-    For omnibus package:
-
-    ```sh
-      sudo editor /etc/gitlab/gitlab.rb
-    ```
-
-    For installations from source:
-
-    ```sh
-      cd /home/git/gitlab
-      sudo -u git -H editor config/gitlab.yml
-    ```
-1.  See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
-1.  Add the provider configuration:
-
-    For omnibus package:
-
-    ```ruby
-      gitlab_rails['omniauth_providers'] = [
-        {
-          "name" => "ultraauth",
-          "app_id" => "OPENID_CLIENT_ID",
-          "app_secret" => "OPENID_CLIENT_SECRET",
-          "args" => {
-            "client_options" => {
-              "redirect_uri" => "https://example.com/users/auth/ultraauth/callback"
-            }
-          }
-        }
-      ]
-    ```
-
-    For installation from source:
-
-    ```
-      - { name: 'ultraauth',
-          app_id: 'OPENID_CLIENT_ID',
-          app_secret: 'OPENID_CLIENT_SECRET',
-          args: {
-            client_options: {
-              redirect_uri: 'https://example.com/users/auth/ultraauth/callback'
-            }
-          }
-        }
-    ```
-    __Replace `https://example.com/users/auth/ultraauth/callback` with your application's Callback URL.__
-1.  Change `OPENID_CLIENT_ID` to the Client ID from the UltraAuth application page.
-1.  Change `OPENID_CLIENT_SECRET` to the Client Secret from the UltraAuth application page.
-1.  Save the configuration file.
-1.  [Reconfigure GitLab]( ../administration/restart_gitlab.md#omnibus-gitlab-reconfigure ) or [restart GitLab]( ../administration/restart_gitlab.md#installations-from-source ) for the changes to take effect if you
-    installed GitLab via Omnibus or from source respectively.
+1. Sign in to [UltraAuth](https://ultraauth.com).
+1. Navigate to [Create an App](https://ultraauth.com/select-strategy) and click on "Ruby on Rails".
+1. Scroll down the page that is displayed to locate the **Client ID** and **Client Secret**.
+   Keep this page open as you continue configuration.
+
+   ![UltraAuth Credentials: OPENID_CLIENT_ID and OPENID_CLIENT_SECRET](img/ultra_auth_credentials.png)
+
+1. Click on "Edit Callback URL" link.
+
+   ![Edit UltraAuth Callback URL](img/ultra_auth_edit_callback_url_highlighted.png)
+
+1. The callback URL will be `http(s)://<your_domain>/users/auth/ultraauth/callback`
+
+   ![UltraAuth Callback URL](img/ultra_auth_edit_callback_url.png)
+
+1. Select **Register application**.
+1. On your GitLab server, open the configuration file.
+
+   For omnibus package:
+
+   ```sh
+   sudo editor /etc/gitlab/gitlab.rb
+   ```
+
+   For installations from source:
+
+   ```sh
+   cd /home/git/gitlab
+   sudo -u git -H editor config/gitlab.yml
+   ```
+
+1. See [Initial OmniAuth Configuration](omniauth.md#initial-omniauth-configuration) for initial settings.
+1. Add the provider configuration:
+
+   For omnibus package:
+
+   ```ruby
+   gitlab_rails['omniauth_providers'] = [
+     {
+       "name" => "ultraauth",
+       "app_id" => "OPENID_CLIENT_ID",
+       "app_secret" => "OPENID_CLIENT_SECRET",
+       "args" => {
+         "client_options" => {
+           "redirect_uri" => "https://example.com/users/auth/ultraauth/callback"
+         }
+       }
+     }
+   ]
+   ```
+
+   For installation from source:
+
+   ```
+   - { name: 'ultraauth',
+       app_id: 'OPENID_CLIENT_ID',
+       app_secret: 'OPENID_CLIENT_SECRET',
+       args: {
+         client_options: {
+           redirect_uri: 'https://example.com/users/auth/ultraauth/callback'
+         }
+       }
+     }
+   ```
+
+   __Replace `https://example.com/users/auth/ultraauth/callback` with your application's Callback URL.__
+
+1. Change `OPENID_CLIENT_ID` to the Client ID from the UltraAuth application page.
+1. Change `OPENID_CLIENT_SECRET` to the Client Secret from the UltraAuth application page.
+1. Save the configuration file.
+1. [Reconfigure GitLab](../administration/restart_gitlab.md#omnibus-gitlab-reconfigure) or [restart GitLab](../administration/restart_gitlab.md#installations-from-source) for the changes to take effect if you
+   installed GitLab via Omnibus or from source respectively.
 
 On the sign in page, there should now be an UltraAuth icon below the regular sign in form.
 Click the icon to begin the authentication process. UltraAuth will ask the user to sign in and authorize the GitLab application.