gitbulk 0.0.7.364823 → 0.0.8.364829

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1cff21a5fb48b6cc4117f6c651afcc140e44b27cf53741653e3ced671037010
-  data.tar.gz: 1b2615ae49a20f25513b312b62e02f6ec643fe2f33cfac564d8e2aef5616815d
+  metadata.gz: cd7f800a675bd30ba38b8f91c543e852766dafe1c14bca17c9a576b31b224952
+  data.tar.gz: 3f93c0eb33ed223ccb386497b3a1d84a46f653ee2036dbb1dd49b55f9f44c22f
 SHA512:
-  metadata.gz: 659d9eefca93abe79278923893df225833473d7f97b9a165da3a1ddd375993c2c8aea7aa6ed4390b4b7b082d8ac96b79ce4982d6e631462a5a30d454b7dd6d34
-  data.tar.gz: 72feedefa815f475ed69e19bbbf5a8f376754399fbc0e77a225e9d7ea3be0afbf68a3e16610cb12c3996d24abb973a6281cba296250c1d90d377f2058eb160ef
+  metadata.gz: 3bbee595f163d84975d8a8c94b3205ddf5065a7ef9bb7bf08a06efd1d4a1766fe7c5139a20a21e6b546a32b759bac963900fb639a46a026761132cd266e11cc5
+  data.tar.gz: dab1e2b185da33e5a3d7606c35b1cf419ac8a70a58de865619de6101d8310b7c261fff57c197da7cf7928bcc5eec09bda8ec65337d984625af7e59a26143e14e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitbulk (0.0.7)
+    gitbulk (0.0.8)
       activesupport
       colorize
       fileutils

data/lib/git-repo-sync/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Ilya Tretyakov, it3xl.ru, git-repo-sync, https://github.com/it3xl/git-repo-sync
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/git-repo-sync/README.md

@@ -0,0 +1,273 @@
+# git-repo-sync
+
+## Synchronization of Branches between Remote Git-repositories
+
+* The **git-repo-sync** is a bash script that synchronizes branches between two remote Git-repositories.
+  * Git-tags are not synchronized.
+* You configure once what branches to synchronize and how.
+  * You have to investigate some time to understand **git-repo-sync** conflict solving strategies and configuring.
+* Your run **git-repo-sync** periodically, preferebly every few minutes.
+
+*Warning!* Before reading the following keep in mind the difference between **local** and **remote** Git repositories.
+
+If your people push (commit) often to a single synchronized Git-branch and do it to different remote Git-repositories, then:
+
+* Run **git-repo-sync** before pushing to such the branch.
+
+### Manual Action of Synchronization
+
+If someone pushed to the same branch (to another remote repo) in between the runing of **git-repo-sync** and your pusing. In this case:
+
+* Run **git-repo-sync**
+* Udpate your local repository (git fetch).
+* Check if your commits (push) wasn't deleted from your remote Git-repository. (FYI. You local commits in your local repository will not be changed!)
+* If it was deleted in the remote repo:
+* merge, rebase, etc., your local branch over the latest remote commits;
+* repeat Git-push for your branch.
+* Repeat everything until your pushed branch will be in expected commits in your remote Git-repository.
+
+This situation is covered by notifications but you have to configure this by yourlself in your enterprise environment.
+
+## Use Cases
+
+* Adhesion of Git-remote-repositories of clients and software/support suppliers. Temporary or permanent.
+* Independence from an external remote Git repository if it is slow and could be out of service time after time.
+* You software teams have independent Git remote repositories.
+
+## Requirements
+
+* Install Git
+* Use bash to run **git-repo-sync**. (It is not tested for zsh)
+* Tune any automation to run **git-repo-sync** periodically - crones, schedulers, Jenkins, GitLab-CI, etc. Or run it periodically yourself.
+
+This is enough for Windows, Arch based Linux (Manjaro), GNU based Linux
+
+### macOS Additional Requirements
+
+* Update bash by running (restart your shell after this)
+  * `brew install bash`
+* Install gAWK (GNU AWK)
+  * `brew install gawk`
+
+### Ubuntu Additional Requirements
+
+* Install gAWK (GNU AWK).
+  * consider [this case](https://askubuntu.com/questions/561621/choosing-awk-version-on-ubuntu-14-04/561626#561626).
+
+### Other Linux Additional Requirements
+
+* Check gawk presence. Run `gawk '{ exit; }'` or see https://unix.stackexchange.com/a/236666/207074
+* Check that bash version is 4.2 or above.
+
+## How to use
+
+Copy **git-repo-sync** somewhere
+
+    git clone https://github.com/it3xl/git-repo-sync.git
+
+Let **git-repo-sync** know location of your remote Git repositories.<br/>
+Modify `url_a` and `url_b` variables in [default_sync_project.sh](https://github.com/it3xl/git-repo-sync/blob/master/repo_settings/default_sync_project.sh).<br/>
+You can use URL-s and file paths.
+
+    url_a=https://example.com/git/my_repo.git
+    
+    url_b='/c/my-folder/my-local-git-repo-folder'
+
+Run periodically the `git-sync.sh` file, which is located in the root of **git-repo-sync**.
+
+    bash  git-sync.sh
+
+The `git-sync.sh` will tell you if there are any troubles. For example you need to update awk to gAWK in Ubuntu.
+
+## The Trade-off
+
+_The Trade-off_ is an automated Git-conflict solving logic of git-repo-sync.
+
+Even if you run **git-repo-sync** periodically and often, you still have a chance to get a Git-conflict. But a small chance.<br/>
+So, you must know what to do in case of Git-conflicts solved by git-repo-sync.
+
+### Minimize chances of The Trade-off
+
+Run **git-repo-sync** before Git-pushing. I.e. synchronize your both Git-remote-repos before pushing into any of them.<br/>
+In this case, Git will be responsible for conflict resolution, not **git-repo-sync**.
+
+### When git-repo-sync will be solving the conflicts.
+
+You should have the both
+
+- You run **git-repo-sync** rarely. I.e. someone aready pushed commites exactly to your branch after last running of **git-repo-sync**.
+- And you and your teammate have pushed changes to the same Git-branch but through different remote repositories and your remote repositories are no synchronized between your Git-pushes.
+
+Basically, you don't know about **git-repo-sync** until you are in this situation.
+
+### Behavior of git-repo-sync in case of Git-conflicst
+
+**git-repo-sync** sees a Git-conflict and uses one of Conflict Solving strategies described below.<br/>
+As a result, you should provide the below steps to fix The Trade-off.
+
+### Your steps to fix The Trade-off
+
+The main idea is "Re-push your local Git-commit in case of a conflict".
+
+- Run **git-repo-sync** to synchronize both Git-remote-repositories (if you have no periodical auto-runs).
+
+- Upload changes from your remote Git-repository to your local repository.
+- Check if you local commit have lost its remote counterpart. I.e. the commit exist only in your local repository.
+  - Performe Git-merge/rebase of your local commit.
+  - Performe Git-push of your changes.
+
+- Run **git-repo-sync** to synchronize your changes with changes from another side Git-remote-repository (if you have no periodical auto-runs).
+
+### How do I know if there were Git-conflicts
+
+- Check it manually. This is described in the above steps.
+- **git-repo-sync** has notifications over plain text files. Ask your DevOps to distribute it.
+
+## Using On Linux
+
+Run `git-sync.sh` and it will tell you what **git-repo-sync** needs.<br/>
+In most cases you have to install gAWK. This applies to Ubuntu.<br/>
+Docker Alpine Linux images require *bash* and *gAWK* to be installed.<br/>
+You have to update the *bash* if you use an extra old Linux distro.
+
+## Using on Windows
+
+Ha! You're lucky. You have to do nothing and have five options to run **git-repo-sync**.
+
+Open PowerShell or CMD in the **git-repo-sync** folder and run one of three.
+
+    "C:\Program Files\Git\bin\bash.exe" git-sync.sh
+    "C:\Program Files\Git\usr\bin\bash.exe" git-sync.sh
+    "C:\Program Files\Git\git-bash.exe" git-sync.sh
+
+Or you can reinstall Git and integrate the bash into your Windows during installation. Then run
+
+    bash  git-sync.sh
+
+Or you can try to update the PATH environment variable. Try to add the following (that wasn't tested by me)
+
+    ;C:\Program Files\Git\cmd;C:\Program Files\Git\mingw64\bin;C:\Program Files\Git\usr\bin
+
+## Do not synchronize all branches
+
+Despite that there are [fair cases](https://github.com/it3xl/git-repo-sync/issues/3#issuecomment-771494886) when it is useful to sync all branches, this is not always a good idea.<br/>
+Some well know Git-servers block some branches in different ways. Some of them create "trash"-branches which you do not want to see synchronized.<br/>
+
+So, you can synchronize branches that have special prefixes only.<br/>
+You could configure these prefixes in [default_sync_project.sh](https://github.com/it3xl/git-repo-sync/blob/master/repo_settings/default_sync_project.sh) configuration file.<br/>
+What's important, these prefixes are related to correspondent *conflict solving strategies*.
+
+## Conflict Solving Strategies
+
+### The Victim Strategy
+
+By default all branches are synced under this strategy.<br/>
+You can do whatever you want with such branches from both sides (repositories).<br/>
+In case of commit conflicts, any newest commit will win.<br/>
+You can relocate branches to any position, delete and move them back in history if you run **git-repo-sync** regularly.<br/>
+
+Use the following variable to limit branches synchronized by this strategy.
+
+    victim_branches_prefix=@
+
+The most common value for victim_branches_prefix is "@".<br/>
+In this case only branches that start with `@` will be synchronized.
+E.g. `@dev`, `@dev-staging`, `@test`, `@test-staging`, `@my-feature`, etc.
+
+### The Conventional Strategy
+
+By using this strategy you limit what your teammates may do from another side repository with branches on your side remote repository.
+
+Branches with the following prefix will be owned by the repo from [url_a](https://github.com/it3xl/git-repo-sync/blob/master/repo_settings/default_sync_project.sh) variable. Let's call it *A side*.
+
+    side_a_conventional_branches_prefix=client-
+
+Branches with the following prefix will be owned by the repo from [url_b](https://github.com/it3xl/git-repo-sync/blob/master/repo_settings/default_sync_project.sh) variable. Let's call it *B side*.
+
+    side_b_conventional_branches_prefix=vendor-
+
+Other examples of prefix pairs: `a-`, `b-`; `microsoft/`, `google/`; `foo-`, `bar-`;
+
+On the owning side repo: You can do whatever you want with such branches.
+
+On a repo of another side:<br/>
+You can do fast-forward updates and merges.<br/>
+You can move such branches back in Git-history if you run **git-repo-sync** periodically.
+
+All commit conflicts will be solved in favor of the owning side.<br/>
+
+### Other Unimplemented Strategies
+
+Just propouse something interesting.<br/>
+BTW, the Victim and Conventional approaches cover 80% of cases you need (I beleive).
+
+## Disaster Protection
+
+People have to make mistakes to become better. This is normal. But let's protect our clients from such the mistakes.<br/>
+Define *sync_enabling_branch* variable
+
+    sync_enabling_branch=it3xl_git_repo_sync_enabled
+
+Its value may represent any branch name.<br/>
+Examples: `@test`, `client-prod`, `vendor-master`, `it3xl_git_repo_sync_enabled`.<br/>
+
+The **git-repo-sync** will check if such a branch exist in both remote repositories and that it has the same or related commits, i.e. its commits are located in the same Git-tree.<br/>
+This will protect you from occasional adhesion of unrelated git-repositories and deletion of branches that have the same names.<br/>
+Git may store many independent projects (trees) in the same repository and this is uncommon behavior for many users.
+
+I advise to use `it3xl_git_repo_sync_enabled` branch name to make this explicit for others that their remote Git-repo is synchronized with another remote repo.<br/>
+They could search for the word *it3xl_git_repo_sync_enabled* in the Internet and understand the applied sync solution.
+
+Be aware that a branch mentioned in the `sync_enabling_branch` variable will be alwasy synchronized by **git-repo-sync**.<br/>
+Probably this is not a good idea to specify here the `master` branch name because a branch mentioned in `sync_enabling_branch` will be synchronized under the Victim strategy. But you can specify there a branch with one of your conventional prefixes for the Conventional syncing of it. For example `client-master`.
+
+## Notes, Drawbacks & Limitations
+* Usage with SSH isn't tested but possible.
+* **git-repo-sync** is resilient for HTTP fails and interruptions.
+* It has protections from an occasional deletion of your entire remote repository.
+* Arbitrary Git-history rewriting is supported.
+* Within a single installation, **git-repo-sync** can synchronize as many pairs of Git-repositories as you want. Every sync pair is a sync project for **git-repo-sync**.
+* Git-tags are not synchronized.
+  * Remarks why: Some Git-servers block manipulations with Git-tags. Time was saved for research and covering all possible cases. Another repo's tags created issues for Git-tag based CI/CD-s.
+* **git-repo-sync** doesn't attempt to do Git-merge or rebase. Just FYI.
+
+## Support Operations
+
+### Remote Repo Replacing Support
+
+This is a real case of my customer. You may want to synchronize your existing Git-repo with a Git-repo of your new software parnter.
+
+Option 1.<br/>
+Create a new git-repo-sync project and use it (project description file or environment variables).
+
+Option 2.<br/>
+Modify your existing project. Update its description file or environment variables.<br/>
+Delete `git-repo-sync/sync-projects/<your-sync-project-name>` directory.<br/>
+Start synchronization as usual.
+
+Option 3.<br/>
+Your Git-repository is extra huge and you can't recreate it. This is a TL;DR. Ask a Git-professional for a help. 
+
+## Known Issues
+
+### It is still untracked
+`Something went wrong for <your-branch>. It is still untracked.
+Possibly the program or the network were interrupted.`
+
+* Disable your antivirus or Check Point.
+* Check if this branch is blocked by your Git-server.
+
+## Automation support
+* **git-repo-sync** works with remote Git repositories asynchronously, by default.
+* It works much faster under \*nix OS-es because Git-bash on Windows is slower. But compare to network latency, this is nothing.
+* You can separate change detection and synchronization phases of **git-repo-sync** for readability of CI/CD logs.
+* Multiple configuration capabilities are supported. Environment, configuration files, combination of them.
+* Integration with **bash Git Credential Helper - [git-cred](https://github.com/it3xl/bash-git-credential-helper)** to obtain credentials from a parent shell environment.
+* You shouldn't do anything in case of connectivity fails. Continue to run **git-repo-sync** periodically and everything will be restored automatically.
+* After every synchronization, analyze notification files to send notifications about branch deletions or commit conflict solving.  
+See `git-repo-sync/sync-projects/<your-sync-project-name>/file-signals/`
+  * `notify_solving` - for conflict solving
+  * `notify_del` - for deletions
+* See [instructions](https://github.com/it3xl/git-repo-sync/blob/master/repo_settings/default_sync_project.sh) on how to configure more synchronization pairs of remote Git repositories.
+* Number of pairs is unlimited. Every pair is a separate sync project.
+

data/lib/git-repo-sync/git-sync.sh

@@ -0,0 +1,31 @@
+# it3xl.ru git-repo-sync https://github.com/it3xl/git-repo-sync
+
+set -euf +x -o pipefail
+
+#echo
+#echo Start $(basename $BASH_SOURCE)
+
+invoke_path="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+source "$invoke_path/util/set_env.sh" "$@"
+
+
+
+echo
+source "$path_git_sync_util/repo_create.sh"
+cd "$path_sync_repo"
+
+
+rm -f "$env_notify_del_file"
+rm -f "$env_notify_solving_file"
+
+source "$path_git_sync_util/restore-after-crash.sh"
+
+
+source "$path_git_sync_util/sync_pass.sh"
+source "$path_git_sync_util/sync_pass.sh"
+
+
+echo
+echo @ RESULT: Successfully completed with $git_sync_pass_num_required sync-pass'/'es.
+#echo
+#echo End $(basename $BASH_SOURCE)

data/lib/git-repo-sync/repo_settings/default_sync_project.sh

@@ -0,0 +1,146 @@
+# it3xl.ru git-repo-sync https://github.com/it3xl/git-repo-sync
+#
+## Post your questions on https://github.com/it3xl/git-repo-sync/issues
+## I will be glad to explain the ambiguities and to improve this instruction for others.
+
+
+# Configure location of your remote Git repositories.
+#
+#url_a=/tmp/bb/gitlab/
+#
+#url_b=/tmp/bb/github/
+
+# Don't sync all branches. Synchronize branches with the following prefix.
+#
+# victim_branches_prefix=@
+
+# Prevent catastrophe!
+# Don't sync repositories without the specified branch in the same Git-tree (same or related commits).
+# 
+# sync_enabling_branch=it3xl_git_repo_sync_enabled
+
+# Limit branch manipulations for another repository side.
+# See "Conventional Syncing strategy" below.
+#
+# side_a_conventional_branches_prefix=client-
+# side_b_conventional_branches_prefix=vendor-
+
+
+# Automation integration. See details below
+#
+# git_sync_project_folder=my-sync-project
+#
+# use_bash_git_credential_helper=1
+
+
+#
+##
+### Descriptions & Explanations
+##
+#
+
+
+## This Configuration File
+#
+# Variables mentioned in this file configure synchronization of two remote Git-repositories.
+# Use the following options to configure your synchronization.
+#
+## Uncomment and modify required variables in this file.
+#
+## Create a copy of this file in one of the following locations
+# * git-repo-sync/repo_settings
+# * git-repo-sync/../git-repo-sync.repo_settings
+# Pass the name of your copied file to git-sync.sh as the first parameter for every run.
+# Invocation example: $ ./git-sync.sh  my-sync-project.sh
+#
+## Create a copy of this file in an arbitrary location.
+# Pass its full path to git-sync.sh as the first parameter for every run.
+# Or use a relative to "git-repo-sync" path.
+#
+## Declare the variables in your script or environment.
+# Warning! Your configuration file will be ignored if your parent environment
+#  or calling script have the git_sync_project_folder variable.
+
+## url_a
+## url_b
+# Let's call your two synchronized remote Git repositories as sides A and B.
+# Then url_a and url_b variables point to git remote repositories of the A and B sides accordingly.
+# It could be an URL or a file path (SSH addresses wasn't tested yet).
+# For paths on Windows use the following notation
+# url_a="/c/my-folder/my-git-local-repo-folder"
+
+## victim_branches_prefix
+# Limit branches which will be synchronized under a Victim Sync strategy.
+# If undefined or empty then all branches will be synced.
+# (except conventionally prefixed branches described below)
+#
+## The Victim Sync strategy.
+# You can do whatever you want with such branches from both remote sides (repositories).
+# In case of commit conflicts, any newest commit will win.
+# You can relocate branches to any position or delete them, etc.
+# You can move a branch back in history if you sync your repos regularly.
+#
+# The most common value is "@".
+# Examples: @dev, @dev-staging, @test, @test-staging
+
+## sync_enabling_branch
+# Represents any branch name.
+# The git-repo-sync will check that such a branch exist in both remote repositories
+# and that it has the same or related commits, i.e. located in the same Git-tree.
+# This will protect you from occasional adhesion of unrelated git-repositories.
+# Git may store many independent projects in the same repository and this is uncommon behavior for many users.
+#
+# We advise to use it3xl_git_repo_sync_enabled name to make it explicit to others that their Git-repo is syncing with another remote repo.
+# Examples: @test, client-prod, vendor-master, it3xl_git_repo_sync_enabled
+
+## side_a_conventional_branches_prefix
+# Branches with a prefix from this variable will be owned by the repo from "url_a". Let's call it A side.
+#
+## side_b_conventional_branches_prefix
+# Branches with a prefix from this variable will be owned by the repo from "url_b". Let's call it B side.
+#
+# Branches with such prefixes will be updated under the Conventional Sync strategy.
+# You can define both or one variable.
+#
+## The Conventional Sync strategy
+# On a repo of the owning side: You can do whatever you want with such branches.
+# On a repo of another side: You can do fast-forward updates and merges.
+#   You can move such a branch back in Git-history from an non-owning side if you run git-repo-sync regularly.
+# All commit conflicts will be solved in favor of the owning side.
+#
+# Example of prefix pairs: client-, vendor-; a-, b-; microsoft/, google/
+
+
+## git_sync_project_folder
+# It defines a folder in which your sync-project artifacts will be stored inside of "git-repo-sync/sync-projects/".
+# In the absence of git_sync_project_folder, its value will be taken from the name of a provided configuration file.
+#
+# Warning! Your configuration file will be ignored if your parent environment
+#  or calling script have this variable. In this case, all required variables must be configured in the parent environment.
+
+
+## use_bash_git_credential_helper=1
+# This variables enables using of the "git-cred", the "bash Git Credential Helper" from https://github.com/it3xl/bash-git-credential-helper
+# 
+# Git-cred allows you to use Git-credential values from environment variables
+#  which are defined automatically by any Continues Integration (CI/CD) tool.
+#
+# You can use "git-cred" as an external tool and tune everything manually.
+# But configuring it here allows you to initialize git-cred only once.
+# BTW, "git-cred" allows a free relocation of your installation "git-repo-sync" folder.
+#
+# * Before using git-cred you must complete the following steps.
+#
+# ** Load Git sub-modules inside of your "git-repo-sync" folder (https://github.com/it3xl/git-repo-sync)
+#
+# ** Before any call to "git-sync.sh" or to "request-git-sync.sh", define the following environment variables in your CI/CD automation server or tool
+#   For the repo in $url_a
+# git_cred_username_repo_a=some-login
+# git_cred_password_repo_a=some-password
+#   For the repo in $url_b
+# git_cred_username_repo_b=another-login
+# git_cred_password_repo_b=another-password
+#
+# ** Assign use_bash_git_credential_helper variable to 1.
+
+

data/lib/git-repo-sync/request-git-sync.sh

@@ -0,0 +1,44 @@
+# it3xl.ru git-repo-sync https://github.com/it3xl/git-repo-sync
+
+set -euf +x -o pipefail
+
+echo
+echo Start $(basename $BASH_SOURCE)
+
+invoke_path="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+source "$invoke_path/util/set_env.sh" "$@"
+
+rm -f "$env_modifications_signal_file"
+rm -f "$env_modifications_signal_file_a"
+rm -f "$env_modifications_signal_file_b"
+
+echo
+source "$path_git_sync_util/repo_create.sh"
+cd "$path_sync_repo"
+
+source "$path_git_sync_util/restore-after-crash.sh"
+
+source "$path_git_sync_util/change_detector.sh"
+
+echo
+if (( $changes_detected == 1 )); then
+    install -D /dev/null "$env_modifications_signal_file"
+    install -D /dev/null "$env_modifications_signal_file_a"
+    install -D /dev/null "$env_modifications_signal_file_b"
+    
+    # Passing of remote refs to prevent excessive network requesting.
+    echo "$remote_refs_a" >> "$env_modifications_signal_file_a"
+
+    echo "$remote_refs_b" >> "$env_modifications_signal_file_b"
+    
+    echo '@' RESULT: Synchronization requested.
+else
+    echo '@' RESULT: Refs are the same. Exit.
+    echo
+    
+    # exit
+fi
+
+
+echo
+echo End $(basename $BASH_SOURCE)

data/lib/git-repo-sync/util/change_detector.sh

@@ -0,0 +1,64 @@
+# it3xl.ru git-repo-sync https://github.com/it3xl/git-repo-sync
+
+if [[ $env_allow_async == 1 ]]; then
+    echo '! Async (async remote refs checks are used)'
+    
+    mkdir -p "$path_async_output"
+
+    git ls-remote --heads "$url_a" $sync_ref_specs > "$path_async_output/remote_refs_a.txt" &
+    pid_remote_refs_a=$!
+    git ls-remote --heads "$url_b" $sync_ref_specs > "$path_async_output/remote_refs_b.txt" &
+    pid_remote_refs_b=$!
+
+    err_remote_refs_a=0;
+    wait $pid_remote_refs_a || err_remote_refs_a=$?
+    err_remote_refs_b=0;
+    wait $pid_remote_refs_b || err_remote_refs_b=$?
+
+    remote_refs_a=$(<"$path_async_output/remote_refs_a.txt")
+    remote_refs_b=$(<"$path_async_output/remote_refs_b.txt")
+
+    if (( $err_remote_refs_a != 0 )); then
+        echo
+        echo "> Async fail | Change detection | $origin_a | Error $err_remote_refs_a"
+        echo "$remote_refs_a"
+        echo ">"
+    fi;
+    if (( $err_remote_refs_b != 0 )); then
+        echo
+        echo "> Async fail | Change detection | $origin_b | Error $err_remote_refs_b"
+        echo "$remote_refs_b"
+        echo ">"
+    fi;
+    if (( $err_remote_refs_a != 0 )); then
+        echo
+        echo "> Exit."
+        exit $err_remote_refs_a;
+    fi;
+    if (( $err_remote_refs_b != 0 )); then
+        echo
+        echo "> Exit."
+        exit $err_remote_refs_b;
+    fi;
+else
+    echo '! Sync (sync remote refs checks are used)'
+    
+    remote_refs_b=$(git ls-remote --heads "$url_b" $sync_ref_specs)
+    remote_refs_a=$(git ls-remote --heads "$url_a" $sync_ref_specs)
+fi;
+
+
+track_refs_a=$(git for-each-ref --format="%(objectname) %(refname)" $track_refspecs_a)
+track_refs_b=$(git for-each-ref --format="%(objectname) %(refname)" $track_refspecs_b)
+
+## remote_count=$(echo "$remote_refs_a" | awk 'END { print NR }';)
+## track_count=$(echo "$track_refs_a" | awk 'END { print NR }';)
+
+export remote_refs_a;
+export remote_refs_b;
+export track_refs_a;
+export track_refs_b;
+
+changes_detected=$($env_awk_edition --file="$path_git_sync_util/gawk/change_detector.gawk")
+echo
+