# GitServer limitations

> Manage potential issues or differences in expected behavior when you use GitServer.

If you use GitServer, there are restrictions on some GitHub operations ,such as fast-forward, rebase, and commit deletion, and how GitServer doesn't enforce security. This page also covers important configuration options, such as to disable deltification on your GitHub repository, and functional limitations such as the lack of support for shallow clones and progress indicators for `git push` commands.

GitServer also has differences in how you handle annotated tags and branch hierarchies, which protocols it supports, its impact on storage, and the correct procedure to follow if you need to recreate the GitServer mapping folder.

## Avoid fast-forward, rebase, and deleting GitHub commits

Rebasing and deletion of commits are already restrictions when you push to a regular GitHub server. The fast-forward restriction is caused by the fact that in GitHub, a single commit can be in more than one branch. In UVCS, every changeset links to a single branch, and can’t be on more than one branch simultaneously.

## Security isn’t enforced in GitServer

GitServer doesn’t perform security checks for exported repositories. GitHub clients can download the entire repository content and push changes to the repository. To restrict the repositories that are visible to GitServer, use the `export.repo` entry in the `gitserver.conf` file.

## Disable deltification on Git repositories

GitServer doesn’t support deltified GitHub packages. This is a performance restriction to speed up metadata and data conversion between the two systems. To disable deltification on the Git side, run the following command on your Git repository:

```text
git config --global pack.window 0
```

If GitServer receives a pack with deltas during a push, GitServer displays the following error message:

```text
git deltas are not supported. Please, set the 'pack.window 0' config variable or run an 'git repack -a -f -d' command
```

The message includes clear instructions on how to repack the Git repository to disable deltas:

```text
git repack -a -f -d
```

## GitServer doesn’t support shallow clones

GitServer doesn’t support shallow clones. Depending on the Git client version, the following error message will be displayed:

```text
> git clone git://localhost/default  --depth=1
Cloning into 's'...
fatal: Server does not support shallow clients
```

## The GitHub push command doesn’t show progress

The `git push` command doesn’t show progress while you import objects into UVCS.

## Annotated tags

Annotated tags import correctly to UVCS, but if you clone them again from GitServer into GitHub, they export as lightweight tags.

## Branch names and hierarchies

Branch names with multiple levels can be different in GitHub and UVCS. For example, a branch named `/main/Fix-5.0/scm003 converts to `main-Fix-5.0-scm003\` in GitHub.

## Supported GitHub protocols

You can access GitServer through both `git://` and `http://` protocols. GitServer doesn’t support SSH.

## Storage restrictions

When you export a repository with GitServer, you duplicate the file contents of that repository so it exists both in the UVCS format inside the database, and the GitServer storage folder.

## Recreate the GitServer mapping folder

If you need to recreate the GitServer mappings folder, the new GitHub SHAs might not match the old ones. The following actions are examples that create new GitHub SHAs that don’t match the old ones:

* Edit a changeset comment.
* Perform a replica that affects any of the mapped changesets, such as adding a new merge link.

This means that after you recreate the GitHub mappings, you always need to create a new GitHub repository and clone it from UVCS. If you reuse the previous GitHub repository, it can cause duplicated commits and also duplicate changesets when you push changes back to UVCS.