Гит ошибка 500

• Broken pipe errors on git push
  • Increase the POST buffer size in Git
  • RPC failed; curl 92 HTTP/2 stream 0 was not closed cleanly: INTERNAL_ERROR (err 2)
  • Check your SSH configuration
  • Running a git repack
  • Upgrade your Git client
• ssh_exchange_identification error
• Timeout during git push / git pull
• git clone over HTTP fails with transfer closed with outstanding read data remaining error
• Password expired error on Git fetch via SSH for LDAP user
• Error on Git fetch: “HTTP Basic: Access Denied”
• 401 errors logged during successful git clone
• 403 error when performing Git operations over HTTP

Sometimes things don’t work the way they should or as you might expect when
you’re using Git. Here are some tips on troubleshooting and resolving issues
with Git.

Broken pipe errors on git push

‘Broken pipe’ errors can occur when attempting to push to a remote repository.
When pushing you usually see:

Write failed: Broken pipe
fatal: The remote end hung up unexpectedly

To fix this issue, here are some possible solutions.

Increase the POST buffer size in Git

If you’re using Git over HTTP instead of SSH, you can try increasing the POST buffer size in Git
configuration.

Example of an error during a clone:
fatal: pack has bad object at offset XXXXXXXXX: inflate returned -5

Open a terminal and enter:

git config http.postBuffer 52428800

The value is specified in bytes, so in the above case the buffer size has been
set to 50 MB. The default is 1 MB.

RPC failed; curl 92 HTTP/2 stream 0 was not closed cleanly: INTERNAL_ERROR (err 2)

This problem may be caused by a slow internet connection. If you use Git over HTTP
instead of SSH, try one of these fixes:

• Increase the POST buffer size in the Git configuration with git config http.postBuffer 52428800.
• Switch to the HTTP/1.1 protocol with git config http.version HTTP/1.1.

If neither approach fixes the error, you may need a different internet service provider.

Check your SSH configuration

If pushing over SSH, first check your SSH configuration as ‘Broken pipe’
errors can sometimes be caused by underlying issues with SSH (such as
authentication). Make sure that SSH is correctly configured by following the
instructions in the SSH troubleshooting documentation.

If you’re a GitLab administrator with server access, you can also prevent
session timeouts by configuring SSH keep-alive on the client or the server.

To configure SSH on the client side:

• On UNIX, edit ~/.ssh/config (create the file if it doesn’t exist) and
  add or edit:

  Host your-gitlab-instance-url.com
    ServerAliveInterval 60
    ServerAliveCountMax 5
  

• On Windows, if you are using PuTTY, go to your session properties, then
  go to “Connection” and under “Sending of null packets to keep
  session active”, set Seconds between keepalives (0 to turn off) to 60.

To configure SSH on the server side, edit /etc/ssh/sshd_config and add:

ClientAliveInterval 60
ClientAliveCountMax 5

Running a git repack

If ‘pack-objects’ type errors are also being displayed, you can try to
run a git repack before attempting to push to the remote repository again:

Upgrade your Git client

In case you’re running an older version of Git (< 2.9), consider upgrading
to >= 2.9 (see Broken pipe when pushing to Git repository).

ssh_exchange_identification error

Users may experience the following error when attempting to push or pull
using Git over SSH:

Please make sure you have the correct access rights
and the repository exists.
...
ssh_exchange_identification: read: Connection reset by peer
fatal: Could not read from remote repository.

or

ssh_exchange_identification: Connection closed by remote host
fatal: The remote end hung up unexpectedly

or

kex_exchange_identification: Connection closed by remote host
Connection closed by x.x.x.x port 22

This error usually indicates that SSH daemon’s MaxStartups value is throttling
SSH connections. This setting specifies the maximum number of concurrent, unauthenticated
connections to the SSH daemon. This affects users with proper authentication
credentials (SSH keys) because every connection is ‘unauthenticated’ in the
beginning. The default value is 10.

Increase MaxStartups on the GitLab server
by adding or modifying the value in /etc/ssh/sshd_config:

100:30:200 means up to 100 SSH sessions are allowed without restriction,
after which 30% of connections are dropped until reaching an absolute maximum of 200.

After you modify the value of MaxStartups, check for any errors in the configuration.

sudo sshd -t -f /etc/ssh/sshd_config

If the configuration check runs without errors, it should be safe to restart the
SSH daemon for the change to take effect.

# Debian/Ubuntu
sudo systemctl restart ssh

# CentOS/RHEL
sudo service sshd restart

Timeout during git push / git pull

If pulling/pushing from/to your repository ends up taking more than 50 seconds,
a timeout is issued. It contains a log of the number of operations performed
and their respective timings, like the example below:

remote: Running checks for branch: master
remote: Scanning for LFS objects... (153ms)
remote: Calculating new repository size... (cancelled after 729ms)

This could be used to further investigate what operation is performing poorly
and provide GitLab with more information on how to improve the service.

git clone over HTTP fails with transfer closed with outstanding read data remaining error

Sometimes, when cloning old or large repositories, the following error is thrown:

error: RPC failed; curl 18 transfer closed with outstanding read data remaining
fatal: The remote end hung up unexpectedly
fatal: early EOF
fatal: index-pack failed

This problem is common in Git itself, due to its inability to handle large files or large quantities of files.
Git LFS was created to work around this problem; however, even it has limitations. It’s usually due to one of these reasons:

• The number of files in the repository.
• The number of revisions in the history.
• The existence of large files in the repository.

The root causes vary, so multiple potential solutions exist, and you may need to
apply more than one:

• If this error occurs when cloning a large repository, you can
  decrease the cloning depth
  to a value of 1. For example:

• You can increase the
  http.postBuffer
  value in your local Git configuration from the default 1 MB value to a value greater
  than the repository size. For example, if git clone fails when cloning a 500 MB
  repository, you should set http.postBuffer to 524288000:

  # Set the http.postBuffer size, in bytes
  git config http.postBuffer 524288000
  

• You can increase the http.postBuffer on the server side:

  1. Modify the GitLab instance’s
     gitlab.rb file:

     gitaly['configuration'] = {
       # ...
       git: {
         # ...
         config: [
           # Set the http.postBuffer size, in bytes
           {key: "http.postBuffer", value: "524288000"},
         ],
       },
     }
     

  2. After applying this change, apply the configuration change:

     sudo gitlab-ctl reconfigure
     

For example, if a repository has a very long history and no large files, changing
the depth should fix the problem. However, if a repository has very large files,
even a depth of 1 may be too large, thus requiring the postBuffer change.
If you increase your local postBuffer but the NGINX value on the backend is still
too small, the error persists.

Modifying the server is not always an option, and introduces more potential risk.
Attempt local changes first.

Password expired error on Git fetch via SSH for LDAP user

If git fetch returns this HTTP 403 Forbidden error on a self-managed instance of
GitLab, the password expiration date (users.password_expires_at) for this user in the
GitLab database is a date in the past:

Your password expired. Please access GitLab from a web browser to update your password.

Requests made with a SSO account and where password_expires_at is not null
return this error:

"403 Forbidden - Your password expired. Please access GitLab from a web browser to update your password."

To resolve this issue, you can update the password expiration by either:

• Using the gitlab-rails console:

  gitlab-rails console
  user.update!(password_expires_at: nil)
  

• Using gitlab-psql:

   # gitlab-psql
   UPDATE users SET password_expires_at = null WHERE username='<USERNAME>';
  

The bug was reported in this issue.

Error on Git fetch: “HTTP Basic: Access Denied”

If you receive an HTTP Basic: Access denied error when using Git over HTTP(S),
refer to the two-factor authentication troubleshooting guide.

401 errors logged during successful git clone

When cloning a repository via HTTP, the
production_json.log file
may show an initial status of 401 (unauthorized), quickly followed by a 200.

{
   "method":"GET",
   "path":"/group/project.git/info/refs",
   "format":"*/*",
   "controller":"Repositories::GitHttpController",
   "action":"info_refs",
   "status":401,
   "time":"2023-04-18T22:55:15.371Z",
   "remote_ip":"x.x.x.x",
   "ua":"git/2.39.2",
   "correlation_id":"01GYB98MBM28T981DJDGAD98WZ",
   "duration_s":0.03585
}
{
   "method":"GET",
   "path":"/group/project.git/info/refs",
   "format":"*/*",
   "controller":"Repositories::GitHttpController",
   "action":"info_refs",
   "status":200,
   "time":"2023-04-18T22:55:15.714Z",
   "remote_ip":"x.x.x.x",
   "user_id":1,
   "username":"root",
   "ua":"git/2.39.2",
   "correlation_id":"01GYB98MJ0CA3G9K8WDH7HWMQX",
   "duration_s":0.17111
}

You should expect this initial 401 log entry for each Git operation performed over HTTP,
due to how HTTP Basic authentication works.

When the Git client initiates a clone, the initial request sent to GitLab does not provide
any authentication details. GitLab returns a 401 Unauthorized result for that request.
A few milliseconds later, the Git client sends a follow-up request containing authentication
details. This second request should succeed, and result in a 200 OK log entry.

If a 401 log entry lacks a corresponding 200 log entry, the Git client is likely using either:

• An incorrect password.
• An expired or revoked token.an incorrect

If not rectified, you could encounter
403 (Forbidden) errors
instead.

403 error when performing Git operations over HTTP

When performing Git operations over HTTP, a 403 (Forbidden) error indicates that
your IP address has been blocked by the failed-authentication ban:

fatal: unable to access 'https://gitlab.com/group/project.git/': The requested URL returned error: 403

The 403 can be seen in the production_json.log:

{
   "method":"GET",
   "path":"/group/project.git/info/refs",
   "format":"*/*",
   "controller":"Repositories::GitHttpController",
   "action":"info_refs",
   "status":403,
   "time":"2023-04-19T22:14:25.894Z",
   "remote_ip":"x.x.x.x",
   "user_id":1,
   "username":"root",
   "ua":"git/2.39.2",
   "correlation_id":"01GYDSAKAN2SPZPAMJNRWW5H8S",
   "duration_s":0.00875
}

If your IP address has been blocked, a corresponding log entry exists in the
auth_json.log:

{
    "severity":"ERROR",
    "time":"2023-04-19T22:14:25.893Z",
    "correlation_id":"01GYDSAKAN2SPZPAMJNRWW5H8S",
    "message":"Rack_Attack",
    "env":"blocklist",
    "remote_ip":"x.x.x.x",
    "request_method":"GET",
    "path":"/group/project.git/info/refs?service=git-upload-pack"}

The failed authentication ban limits differ depending if you are using a
self-managed instance
or GitLab.com.

If you’re having trouble cloning a repository, check these common errors.

HTTPS cloning errors

There are a few common errors when using HTTPS with Git. These errors usually indicate you have an old version of Git, or you don’t have access to the repository.

Here’s an example of an HTTPS error you might receive:

> error: The requested URL returned error: 401 while accessing
> https://github.com/USER/REPO.git/info/refs?service=git-receive-pack
> fatal: HTTP request failed

> Error: The requested URL returned error: 403 while accessing
> https://github.com/USER/REPO.git/info/refs
> fatal: HTTP request failed

> Error: https://github.com/USER/REPO.git/info/refs not found: did you run git
> update-server-info on the server?

Check your Git version

There’s no minimum Git version necessary to interact with GitHub, but we’ve found version 1.7.10 to be a comfortable stable version that’s available on many platforms. You can always download the latest version on the Git website.

Ensure the remote is correct

The repository you’re trying to fetch must exist on GitHub.com, and the URL is case-sensitive.

You can find the URL of the local repository by opening the command line and
typing git remote -v:

$ git remote -v
# View existing remotes
> origin  https://github.com/ghost/reactivecocoa.git (fetch)
> origin  https://github.com/ghost/reactivecocoa.git (push)

$ git remote set-url origin https://github.com/ghost/ReactiveCocoa.git
# Change the 'origin' remote's URL

$ git remote -v
# Verify new remote URL
> origin  https://github.com/ghost/ReactiveCocoa.git (fetch)
> origin  https://github.com/ghost/ReactiveCocoa.git (push)

Alternatively, you can change the URL through our
GitHub Desktop application.

Provide an access token

To access GitHub, you must authenticate with a personal access token instead of your password. For more information, see «Managing your personal access tokens.»

If you are accessing an organization that uses SAML SSO and you are using a personal access token (classic), you must also authorize your personal access token to access the organization before you authenticate. For more information, see «About authentication with SAML single sign-on» and «Authorizing a personal access token for use with SAML single sign-on.»

Check your permissions

When prompted for a username and password, make sure you use an account that has access to the repository.

Tip: If you don’t want to enter your credentials every time you interact with the remote repository, you can turn on credential caching. If you are already using credential caching, please make sure that your computer has the correct credentials cached. Incorrect or out of date credentials will cause authentication to fail.

Use SSH instead

If you’ve previously set up SSH keys, you can use the SSH clone URL instead of HTTPS. For more information, see «About remote repositories.»

Error: Repository not found

If you see this error when cloning a repository, it means that the repository does not exist or you do not have permission to access it. There are a few solutions to this error, depending on the cause.

Check your spelling

Typos happen, and repository names are case-sensitive. If you try to clone git@github.com:user/repo.git, but the repository is really named User/Repo you will receive this error.

To avoid this error, when cloning, always copy and paste the clone URL from the repository’s page. For more information, see «Cloning a repository.»

To update the remote on an existing repository, see «Managing remote repositories».

Checking your permissions

If you are trying to clone a private repository but do not have permission to view the repository, you will receive this error.

Make sure that you have access to the repository in one of these ways:

• The owner of the repository
• A collaborator on the repository
• A member of a team that has access to the repository (if the repository belongs to an organization)

Check your SSH access

In rare circumstances, you may not have the proper SSH access to a repository.

You should ensure that the SSH key you are using is attached to your personal account on GitHub. You can check this by typing
the following into the command line:

$ ssh -T git@github.com
> Hi USERNAME! You've successfully authenticated, but GitHub does not
> provide shell access.

If the repository belongs to an organization and you’re using an SSH key generated by an OAuth app, OAuth app access may have been restricted by an organization owner. For more information, see «About OAuth app access restrictions.»

For more information, see Adding a new SSH key to your GitHub account.

Check that the repository really exists

If all else fails, make sure that the repository really exists on GitHub.com!
If you’re trying to push to a repository that doesn’t exist, you’ll get this error.

Error: Remote HEAD refers to nonexistent ref, unable to checkout

This error occurs if the default branch of a repository has been deleted on GitHub.com.

Detecting this error is simple; Git will warn you when you try to clone the repository:

$ git clone https://github.com/USER/REPO.git
# Clone a repo
> Cloning into 'repo'...
> remote: Counting objects: 66179, done.
> remote: Compressing objects: 100% (15587/15587), done.
> remote: Total 66179 (delta 46985), reused 65596 (delta 46402)
> Receiving objects: 100% (66179/66179), 51.66 MiB | 667 KiB/s, done.
> Resolving deltas: 100% (46985/46985), done.
> warning: remote HEAD refers to nonexistent ref, unable to checkout.

To fix the error, you’ll need to be an administrator of the repository on GitHub.com.
You’ll want to change the default branch of the repository.

After that, you can get a list of all the available branches from the command line:

$ git branch -a
# Lists ALL the branches
>   remotes/origin/awesome
>   remotes/origin/more-work
>   remotes/origin/new-main

Then, you can just switch to your new branch:

$ git checkout new-main
# Create and checkout a tracking branch
> Branch new-main set up to track remote branch new-main from origin.
> Switched to a new branch 'new-main'

When trying to push my code into an empty repo, I get «Error: fatal: unable to access ‘http://user%40domain:***@web-server/Bonobo.Git.Server/Dashboard_FrontEnd.git/’: The requested URL returned error: 500» (user, domain and web-server used in place of redacted info).

I’ve checked all the possible GitHub open/closed issues, Google searches and other resources I can find for the past hour and have had no luck. This is not related to the 500.19 issue getting the IIS server error.

Any help would be greatly appreciated as I’m currently at a loss.

--AppSettings.webpages:Enabled: 'false'
--AppSettings.ClientValidationEnabled: 'true'
--AppSettings.UnobtrusiveJavaScriptEnabled: 'true'
--AppSettings.UserConfiguration: '~\App_Data\config.xml'
--AppSettings.DefaultRepositoriesDirectory: '~\App_Data\Repositories'
--AppSettings.GitPath: '~\App_Data\Git\git.exe'
--AppSettings.GitHomePath: '~\App_Data'
--AppSettings.RecoveryDataPath: '~\App_Data\Recovery'
--AppSettings.LogDirectory: '~\App_Data\Logs'
--AppSettings.serilog:minimum-level: 'Information'
--AppSettings.AuthenticationProvider: 'Cookies'
--AppSettings.ImportWindowsAuthUsersAsAdmin: 'false'
--AppSettings.MembershipService: 'ActiveDirectory'
--AppSettings.ActiveDirectoryDefaultDomain: 'domain.com'
--AppSettings.ActiveDirectoryBackendPath: '~\App_Data\ADBackend'
--AppSettings.ActiveDirectoryMemberGroupName: 'MemberGroup'
--AppSettings.ActiveDirectoryRoleMapping: 'Administrator=Admin group'
User Configuration:
--User config file: 'C:\inetpub\wwwroot\Bonobo.Git.Server\App_Data\config.xml'
--User config readable: OK
--User config saveable: OK
--User config folder: Exists, 4 files, 8 entries, writeable
Repo Directory
--Configured repo path: '~\App_Data\Repositories'
--Effective repo path: 'C:\inetpub\wwwroot\Bonobo.Git.Server\App_Data\Repositories'
--Repo dir: Exists, 1 files, 2 entries, writeable
Git Exe
--Git path: 'C:\inetpub\wwwroot\Bonobo.Git.Server\App_Data\Git\git.exe'
--Git.exe exists: OK
Federated Authentication
--Not Enabled: 
Active Directory
--Backend folder exists: OK
--Backend folder: Exists, 0 files, 4 entries, writeable
--User count: 28
AD Teams
AD Roles
--Administrator: 10 members
Internal Membership
--Not Enabled
**********************************************************************************
Exception Log
--LogFileName: : C:\inetpub\wwwroot\Bonobo.Git.Server\App_Data\Logs\log-20171119.txt
--Log File total length: 554105
--Starting log dump from : 544105
ainName)
2017-11-19 11:04:27.456 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.487 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.519 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.551 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.599 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.614 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.645 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.676 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.692 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.723 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.755 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.770 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.801 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.833 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.848 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.880 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.911 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.942 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.958 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:27.989 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:28.020 -05:00 [Error] Failed to create Directory context for domain "emaildomain.org".
System.DirectoryServices.ActiveDirectory.ActiveDirectoryObjectNotFoundException: The specified domain does not exist or cannot be contacted.
   at System.DirectoryServices.ActiveDirectory.Domain.GetDomain(DirectoryContext context)
   at Bonobo.Git.Server.Helpers.ADHelper.GetDomain(String parsedDomainName)
2017-11-19 11:04:28.117 -05:00 [Information] Searching for group "TSC_Support group" in domain "domain.com"
2017-11-19 11:05:02.447 -05:00 [Warning] GitAuth: No auth header, anon operations not allowed
2017-11-19 11:05:02.447 -05:00 [Warning] GitAuth: No auth header, anon operations not allowed
2017-11-19 11:05:02.478 -05:00 [Error] Error caught in GitController
System.FormatException: Invalid length for a Base-64 char array or string.
   at System.Convert.FromBase64_Decode(Char* startInputPtr, Int32 inputLength, Byte* startDestPtr, Int32 destLength)
   at System.Convert.FromBase64CharPtr(Char* inputPtr, Int32 inputLength)
   at System.Convert.FromBase64String(String s)
   at Bonobo.Git.Server.GitAuthorizeAttribute.IsUserAuthorized(String authHeader, HttpContextBase httpContext)
   at Bonobo.Git.Server.GitAuthorizeAttribute.OnAuthorization(AuthorizationContext filterContext)
   at System.Web.Mvc.ControllerActionInvoker.InvokeAuthorizationFilters(ControllerContext controllerContext, IList`1 filters, ActionDescriptor actionDescriptor)
   at System.Web.Mvc.Async.AsyncControllerActionInvoker.<>c__DisplayClass21.<BeginInvokeAction>b__19(AsyncCallback asyncCallback, Object asyncState)