# GitSync (Working Title)

Fast, one-to-many git working directory sync for uncommitted changes

## What

This tool allows a someone to work on a client computer in a normal git workflow (commit sometimes,
save often) to sync their local uncommitted working directory state with one or more servers, so
that compiler and application services (i.e. the intensive part of a development environment) can
be offloaded to more capable, shared, and potentially remote infrastructure.

## How

1. Client checks out git repo (if required)
2. Client runs GitSyncServer on the desired infrastructure (if required)
3. Client runs GitSync, and points it to the local git repo and the IP address of GitSyncServer

### GitSync

1. Begins listening to `git-change` and `file-change` events (this watcher could be external to the service)
2. Runs `NewSession` to negotiate initial state
3. Binds the `git-change` event to the `NewSession` handler
4. Binds the `file-change` event to the `SyncState` handler

#### `NewSession`

0. Terminates any current sessions
1. Gets the current list of git remotes
2. Fetches a list of the last `N` git commit hashes
3. Makes a `NewSessionRequest` to the GitSyncServer (parsing the list of git remotes and commits)
4. GitSyncServer will respond with the latest commit hash that is currently has in common with the
list sent from the client
5. Creates a `Session` from the common commit hash
6. Calls `Session#BuildPatch` on the session object
7. Calls `Session#SendPatchDiff` to update GitSyncServer

#### `Session#BuildPatch`

1. Calls `git diff --cached $COMMON_COMMIT_HASH` and stores the result (the current uncommitted
working directory state) along with an id for this patch (random?)
2. Deletes all stored patches except the two most recent

#### `SyncState`

1. Calls `Session#BuildPatch` to build the next patch
2. Calls `Session#SendPatchDiff` to update GitSyncServer

#### `Session#SendPatchDiff`

1. Checks if `Session` is currently storing 2 patches
    a. If 1 patch is stored, make a `ApplyPatch` request to GitSyncServer with the patch, its id,
    and the common commit hash
    b. If 2 patches are stored, continue
2. Gets a diff from the two most recent patches
3. Makes an `ApplyPatchDiff` request to GitSyncServer with that diff, the patch ids of the two
patches (parent, and next), and the common commit hash

### GitSyncServer

#### `NewSessionRequest`

1. Check the remotes match
2. Run `git fetch`
3. Respond with the most recent common commit hash

#### `ApplyPatch`

1. Checkout the common commit hash (discarding uncommitted changes)
2. Store the patch and its id as the current patch

#### `ApplyPatchDiff`

1. Checkout the common commit hash (discarding uncommitted changes)
2. Check that the parent id from client matches the current patch id
3. Apply the patch diff to the current patch to re-construct the next patch
4. Call `ApplyPatch` with the next patch and its id