ਇੱਕ ਵੱਡੇ SVN ਰੇਪੋ ਨੂੰ Git ਵਿੱਚ ਕਿਵੇਂ ਮਾਈਗਰੇਟ ਕਰਨਾ ਹੈ

ਤੁਹਾਡੀ ਵੱਡੀ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਹਿਜ ਰੂਪ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ

Git ਵਿੱਚ 155,000 ਤੋਂ ਵੱਧ ਸੰਸ਼ੋਧਨਾਂ ਦੇ ਨਾਲ ਇੱਕ ਵਿਸ਼ਾਲ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਮਾਈਗਰੇਟ ਕਰਨਾ ਤੁਹਾਡੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਸਿਸਟਮ ਨੂੰ ਆਧੁਨਿਕ ਬਣਾਉਣ ਲਈ ਇੱਕ ਚੁਣੌਤੀਪੂਰਨ ਪਰ ਜ਼ਰੂਰੀ ਕੰਮ ਹੈ। ਲੀਨਕਸ Red Hat ਸਿਸਟਮ ਉੱਤੇ svn2git ਦਾ ਲਾਭ ਉਠਾਉਂਦੇ ਹੋਏ, ਤੁਸੀਂ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਰੂਪਾਂਤਰਣ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ। ਹਾਲਾਂਕਿ, ਸਮੇਂ-ਸਮੇਂ 'ਤੇ SVN ਰੈਪੋ ਨੂੰ ਸਿੰਕ ਕਰਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਨਵੀਆਂ ਕਮਿਟਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਤਬਦੀਲੀ ਰਣਨੀਤੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਇਹ ਪਹੁੰਚ ਤੁਹਾਨੂੰ ਨਿਰੰਤਰਤਾ ਬਣਾਈ ਰੱਖਣ ਅਤੇ ਡਾਊਨਟਾਈਮ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਚੁਣੌਤੀ ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਹੈ, ਜਿਸਨੂੰ Git LFS ਅਤੇ BFG ਰੇਪੋ ਕਲੀਨਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇੱਥੇ, ਅਸੀਂ ਤੁਹਾਡੀ ਟੀਮ ਦੇ ਵਰਕਫਲੋ ਵਿੱਚ ਵਿਘਨ ਪਾਏ ਬਿਨਾਂ ਇੱਕ ਸੁਚਾਰੂ ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਈ ਰਣਨੀਤੀਆਂ ਅਤੇ ਹੱਲਾਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ।

ਮਾਈਗ੍ਰੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇੱਕ ਵੱਡੀ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ Git ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਦੀਆਂ ਹਨ। ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਲੀਨਕਸ ਮਸ਼ੀਨ ਉੱਤੇ ਕ੍ਰੋਨ ਜੌਬ ਵਜੋਂ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਇਹ ਸਮੇਂ-ਸਮੇਂ ਤੇ ਸਥਾਨਕ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਰਿਮੋਟ ਦੀ ਵਰਤੋਂ ਨਾਲ ਸਮਕਾਲੀ ਕਰਦਾ ਹੈ svnsync sync. ਫਿਰ, ਇਹ ਨਵੇਂ SVN ਸੰਸ਼ੋਧਨਾਂ ਨੂੰ Git ਕਮਿਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲਦਾ ਹੈ svn-all-fast-export --resume-from. ਸਕ੍ਰਿਪਟ ਸਿੰਕ ਵਿਚਕਾਰ ਨਿਰੰਤਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਆਖਰੀ ਰੂਪਾਂਤਰਿਤ SVN ਸੰਸ਼ੋਧਨ ਨੂੰ ਲੌਗ ਕਰਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹ ਸਥਾਨਕ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਧੱਕਦਾ ਹੈ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੇ Git LFS ਵਿੱਚ ਮਾਈਗਰੇਸ਼ਨ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। ਇਹ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ Git LFS ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਇਸ ਨਾਲ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰਦਾ ਹੈ git lfs track, ਅਤੇ ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਕਮਿਟ ਕਰਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ BFG ਰੇਪੋ ਕਲੀਨਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਬੁਲਾਇਆ ਗਿਆ ਹੈ java -jar $BFG_JAR --convert-to-git-lfs, ਮੌਜੂਦਾ ਬਾਈਨਰੀਆਂ ਨੂੰ LFS ਵਿੱਚ ਮਾਈਗ੍ਰੇਟ ਕਰਨ ਲਈ। ਇਹ ਫਿਰ ਨਾਲ ਕੂੜਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ git gc --prune=now --aggressive ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ ਅਤੇ ਅਪਡੇਟ ਕੀਤੇ ਇਤਿਹਾਸ ਨੂੰ ਰਿਮੋਟ 'ਤੇ ਧੱਕਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਇਤਿਹਾਸ ਵਿੱਚ ਗੜਬੜ ਕੀਤੇ ਬਿਨਾਂ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਕ੍ਰੋਨ ਨਾਲ Git ਸਿੰਕ ਨੂੰ SVN ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨਾ

ਲੀਨਕਸ ਕ੍ਰੋਨ ਜੌਬ ਲਈ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ

#!/bin/bash
# Variables
SVN_REPO_URL="http://your-svn-repo-url"
SVN_LOCAL_DIR="/path/to/local/svn"
GIT_REPO_DIR="/path/to/local/git"
LOG_FILE="/path/to/log/file"

# Sync SVN repo
svnsync sync file://$SVN_LOCAL_DIR

# Convert new revisions to Git
LAST_REV=$(tail -n 1 $LOG_FILE)
svn-all-fast-export --resume-from=$LAST_REV $SVN_LOCAL_DIR --rules rules.txt --add-metadata --identity-map users.txt

# Update Git repo
cd $GIT_REPO_DIR
git pull
git push

# Log last revision
svn info $SVN_LOCAL_DIR | grep "Revision:" | awk '{print $2}' >> $LOG_FILE

Git LFS ਅਤੇ BFG ਰੇਪੋ ਕਲੀਨਰ ਨਾਲ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲਣਾ

Git LFS ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਈ Bash ਸਕ੍ਰਿਪਟ

#!/bin/bash
# Variables
GIT_REPO_DIR="/path/to/local/git"
BFG_JAR="/path/to/bfg.jar"

# Initialize Git LFS
cd $GIT_REPO_DIR
git lfs install

# Add binary files to Git LFS tracking
git lfs track "*.bin"
git add .gitattributes
git commit -m "Track binary files with LFS"

# Use BFG to migrate binaries to LFS
java -jar $BFG_JAR --convert-to-git-lfs '*.bin' --no-blob-protection

# Cleanup and push changes
git reflog expire --expire=now --all
git gc --prune=now --aggressive
git push origin --force --all
git push origin --force --tags

ਵੱਡੇ SVN ਤੋਂ Git ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਈ ਨਿਰਵਿਘਨ ਪਰਿਵਰਤਨ ਰਣਨੀਤੀਆਂ

ਜਦੋਂ ਇੱਕ ਵੱਡੇ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ Git ਵਿੱਚ ਮਾਈਗਰੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਰੁਕਾਵਟਾਂ ਤੋਂ ਬਚਣ ਲਈ ਇੱਕ ਨਿਰਵਿਘਨ ਤਬਦੀਲੀ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਰਣਨੀਤੀ ਇੱਕ ਦੋਹਰੀ ਰਿਪੋਜ਼ਟਰੀ ਸਿਸਟਮ ਨੂੰ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਹੈ। ਇਸ ਸਿਸਟਮ ਵਿੱਚ, SVN ਅਤੇ Git ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਮਾਈਗ੍ਰੇਸ਼ਨ ਪੀਰੀਅਡ ਦੌਰਾਨ ਸਮਕਾਲੀ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਟੀਮਾਂ ਨੂੰ ਘੱਟੋ-ਘੱਟ ਰੁਕਾਵਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਕਿਉਂਕਿ SVN ਵਿੱਚ ਬਦਲਾਅ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਗਿੱਟ ਨਾਲ ਸਿੰਕ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਵਿਚਾਰ ਕਰਨ ਲਈ ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ. Git LFS ਅਤੇ BFG ਰੇਪੋ ਕਲੀਨਰ ਵਰਗੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ Git ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਕੁਸ਼ਲ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਇਹਨਾਂ ਫਾਈਲਾਂ ਦੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਰਿਪੋਜ਼ਟਰੀ ਪ੍ਰਬੰਧਨਯੋਗ ਬਣੀ ਰਹੇ ਅਤੇ ਇਹ ਕਿ ਇਤਿਹਾਸ ਵੱਡੀਆਂ ਬਾਈਨਰੀਆਂ ਨਾਲ ਨਹੀਂ ਘੜਿਆ ਹੋਇਆ ਹੈ, ਜੋ ਕਾਰਵਾਈਆਂ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦਾ ਹੈ।

SVN ਤੋਂ Git ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. SVN ਨੂੰ Git ਵਿੱਚ ਬਦਲਣ ਲਈ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਟੂਲ ਕੀ ਹੈ?
2. SVN ਨੂੰ Git ਵਿੱਚ ਬਦਲਣ ਲਈ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਟੂਲ ਹੈ svn-all-fast-export, ਜੋ ਕਿ ਵੱਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲਦਾ ਹੈ ਅਤੇ ਵਾਧੇ ਵਾਲੇ ਅੱਪਡੇਟ ਲਈ ਸਹਾਇਕ ਹੈ।
3. ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਮੈਂ ਆਪਣੇ SVN ਅਤੇ Git ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਸਿੰਕ ਵਿੱਚ ਕਿਵੇਂ ਰੱਖ ਸਕਦਾ ਹਾਂ?
4. ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ svnsync ਆਪਣੀ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਮੇਂ-ਸਮੇਂ ਤੇ ਇੱਕ ਸਥਾਨਕ ਕਾਪੀ ਨਾਲ ਸਿੰਕ ਕਰਨ ਲਈ ਅਤੇ ਫਿਰ ਨਵੇਂ ਸੰਸ਼ੋਧਨਾਂ ਨੂੰ Git ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ svn-all-fast-export ਦੇ ਨਾਲ --resume-from ਝੰਡਾ
5. ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਮੈਂ ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਾਂ?
6. ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਬੰਧਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ Git LFS ਅਤੇ ਵਰਤਦੇ ਹੋਏ ਮੌਜੂਦਾ ਗਿੱਟ ਇਤਿਹਾਸ ਤੋਂ ਬਦਲਿਆ ਗਿਆ BFG Repo Cleaner.
7. Git LFS ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕੀ ਫਾਇਦੇ ਹਨ?
8. Git LFS ਤੁਹਾਨੂੰ ਮੁੱਖ Git ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਬਾਹਰ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜੋ ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਆਕਾਰ ਨੂੰ ਪ੍ਰਬੰਧਨ ਯੋਗ ਰੱਖਦਾ ਹੈ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ।
9. ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਮਾਈਗਰੇਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਮੈਂ Git ਵਿੱਚ ਕੂੜਾ ਇਕੱਠਾ ਕਿਵੇਂ ਕਰਾਂ?
10. ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੂੜਾ ਇਕੱਠਾ ਕਰੋ git gc --prune=now --aggressive ਬੇਲੋੜੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਅਤੇ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ।
11. ਕੀ ਮੈਂ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਟੋਮੈਟਿਕ ਕਰ ਸਕਦਾ ਹਾਂ?
12. ਹਾਂ, ਤੁਸੀਂ ਨਿਯਮਤ ਅੰਤਰਾਲਾਂ 'ਤੇ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਪਰਿਵਰਤਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਕ੍ਰੋਨ ਜੌਬਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰ ਸਕਦੇ ਹੋ।
13. ਮੈਂ ਮਾਈਗ੍ਰੇਟ ਕੀਤੇ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾ ਸਕਦਾ ਹਾਂ?
14. ਪਰਿਵਰਤਿਤ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰਕੇ ਅਤੇ ਅੰਤਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸਦੀ ਅਸਲ SVN ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਤੁਲਨਾ ਕਰਕੇ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ।
15. ਮੈਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਗਿੱਟ ਇਤਿਹਾਸ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ?
16. ਜੇਕਰ Git ਇਤਿਹਾਸ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਤਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਅੱਪਡੇਟ ਕੀਤੇ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਰਿਮੋਟ 'ਤੇ ਧੱਕੋ ਅਤੇ ਆਪਣੀ ਟੀਮ ਨੂੰ ਤਬਦੀਲੀਆਂ ਬਾਰੇ ਸੂਚਿਤ ਕਰੋ।
17. ਅੰਤਮ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੌਰਾਨ ਮੈਂ ਡਾਊਨਟਾਈਮ ਨੂੰ ਕਿਵੇਂ ਘੱਟ ਕਰ ਸਕਦਾ ਹਾਂ?
18. ਬੰਦ-ਘੰਟਿਆਂ ਦੌਰਾਨ ਅੰਤਿਮ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਕੇ ਅਤੇ ਆਪਣੀ ਟੀਮ ਨੂੰ ਸਮਾਂ-ਸਾਰਣੀ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਦੱਸ ਕੇ ਡਾਊਨਟਾਈਮ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰੋ।

ਗਿੱਟ ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਈ ਇੱਕ ਸਹਿਜ SVN ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇੱਕ ਵੱਡੀ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ Git ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦੀਆਂ ਹਨ। ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਲੀਨਕਸ ਮਸ਼ੀਨ ਉੱਤੇ ਕ੍ਰੋਨ ਜੌਬ ਵਜੋਂ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਇਹ ਸਮੇਂ-ਸਮੇਂ ਤੇ ਸਥਾਨਕ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਰਿਮੋਟ ਦੀ ਵਰਤੋਂ ਨਾਲ ਸਮਕਾਲੀ ਕਰਦਾ ਹੈ svnsync sync. ਫਿਰ, ਇਹ ਨਵੇਂ SVN ਸੰਸ਼ੋਧਨਾਂ ਨੂੰ Git ਕਮਿਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲਦਾ ਹੈ svn-all-fast-export --resume-from. ਸਕ੍ਰਿਪਟ ਸਿੰਕ ਵਿਚਕਾਰ ਨਿਰੰਤਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਆਖਰੀ ਰੂਪਾਂਤਰਿਤ SVN ਸੰਸ਼ੋਧਨ ਨੂੰ ਲੌਗ ਕਰਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹ ਸਥਾਨਕ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਧੱਕਦਾ ਹੈ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦੇ Git LFS ਵਿੱਚ ਮਾਈਗਰੇਸ਼ਨ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। ਇਹ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ Git LFS ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਇਸ ਨਾਲ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰਦਾ ਹੈ git lfs track, ਅਤੇ ਇਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਕਮਿਟ ਕਰਦਾ ਹੈ। ਸਕ੍ਰਿਪਟ BFG ਰੇਪੋ ਕਲੀਨਰ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਬੁਲਾਇਆ ਗਿਆ ਹੈ java -jar $BFG_JAR --convert-to-git-lfs, ਮੌਜੂਦਾ ਬਾਈਨਰੀਆਂ ਨੂੰ LFS ਵਿੱਚ ਮਾਈਗ੍ਰੇਟ ਕਰਨ ਲਈ। ਇਹ ਫਿਰ ਨਾਲ ਕੂੜਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ git gc --prune=now --aggressive ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ ਅਤੇ ਅਪਡੇਟ ਕੀਤੇ ਇਤਿਹਾਸ ਨੂੰ ਰਿਮੋਟ 'ਤੇ ਧੱਕਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਵੱਡੀਆਂ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਨੂੰ ਇਤਿਹਾਸ ਵਿੱਚ ਗੜਬੜ ਕੀਤੇ ਬਿਨਾਂ ਗਿੱਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਮਾਈਗ੍ਰੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਇੱਕ ਵੱਡੀ SVN ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ Git ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨਾ ਇੱਕ ਗੁੰਝਲਦਾਰ ਪਰ ਸਹੀ ਸਾਧਨਾਂ ਅਤੇ ਰਣਨੀਤੀਆਂ ਨਾਲ ਪ੍ਰਾਪਤੀਯੋਗ ਕੰਮ ਹੈ। ਸਿੰਕ ਅਤੇ ਪਰਿਵਰਤਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਕੇ ਅਤੇ ਵੱਡੇ ਬਾਈਨਰੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਕੇ, ਤੁਸੀਂ ਇੱਕ ਨਿਰਵਿਘਨ ਤਬਦੀਲੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ। ਤੁਹਾਡੀ ਟੀਮ ਦੇ ਵਰਕਫਲੋ ਵਿੱਚ ਘੱਟੋ ਘੱਟ ਰੁਕਾਵਟ ਦੇ ਨਾਲ ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣਾ ਅਤੇ ਉਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸਫਲਤਾ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।