Search for a command to run...
Hi, I'm Akshay Kaushik.
Passionate web developer fueled by curiosity and driven to create exceptional user-centric solutions using Python, JavaScript, Django, Next.JS and cutting-edge technologies.
No comments yet. Be the first to comment.
In Linux, swap space allows the system to utilize disk storage for memory management. When the system is running low on physical RAM, it can temporarily move data from memory to swap space on the hard drive. Increasing swap file size provides more “b...
As a React developer, you're probably familiar with the UseState hook. It's a powerful tool that allows you to add state to your functional components. However, it's easy to make mistakes when using it. In this article, we'll explore the most common ...
As technology evolves, it becomes necessary for developers to migrate servers. Whether it's upgrading to a more powerful server or downgrading to a more cost-effective solution, the process remains the same. Recently, I have migrated my server, holdi...
Understanding Concurrency in Python Concurrency refers to the execution of multiple tasks simultaneously in a program. There are primarily three ways to introduce concurrency in Python - Multithreading, Multiprocessing and Asyncio. Each approach has ...
Merging separate Git repositories into a single combined repository is a common need for developers. For example, you may have a frontend and backend repository that are part of the same overall application but kept in separate repositories during initial development.
Bringing these components together into a single repository makes it easier to view, manage, and work with the full codebase as a unified project. However, preserving the commit history and being able to trace code changes back to their original repository is also important.
So, your current setup looks like this:
You've got separate Git repositories for frontend and backend, and now you want to make the Parent Folder the main repository housing both, all while preserving commit histories. Sounds like a plan! Let's dive into the solution.
First things first, let's create a new repository on GitHub (or your preferred hosting service). This will be the main repository for your combined project.
git clone https://github.com/your-username/combined-repo.git
cd combined-repo
# OR In case of offline
git init combined-repo
git remote add origin https://github.com/your-username/combined-repo
Replace "your-username" and "combined-repo" with your GitHub username and the new repository's name. This allows you to pull commits from the source repositories using the remote names as references.
Now, add remotes for both "frontend" and "backend" repositories:
git remote add frontend /path/to/frontend
git remote add backend /path/to/backend
Replace /path/to/frontend and /path/to/backend with the actual paths to your frontend and backend repositories, whether they are offline or online.
Fetch the commits from both repositories:
git fetch frontend
git fetch backend
This pulls the branches and associated commits into your local repository without actually merging anything.
With the commits fetched, you can start merging each repository one at a time.
Create and switch to a new branch for frontend:
First, make a branch for each incoming repository:
git checkout -b frontend-merge frontend/master
Now merge the branch while allowing unrelated histories between the new repo and old repos:
git merge --allow-unrelated-histories FETCH_HEAD
The --allow-unrelated-histories flag is crucial to allow merging branches that do not share a common starting commit.
Next, create directories for the frontend, and move the files accordingly from the merged branches:
mkdir frontend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} frontend/
git commit -m "Merge frontend repository into combined-repo"
Commit to each step. Keeping the code organized this way keeps things isolated during additional merging later.
Repeat the process for the backend repository:
git checkout -b backend-merge backend/master
git merge --allow-unrelated-histories FETCH_HEAD
mkdir backend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} backend/
git commit -m "Merge backend repository into combined-repo"
Now, let's bring it all together:
git checkout master
git merge frontend-merge
git merge backend-merge
As files are brought together from different repositories, merge conflicts can happen just like during normal development.
Code changes from different sources may modify the same parts of a file in incompatible ways. When this happens, Git stops the merge and flags the conflict.
If you encounter a "refusing to merge unrelated histories" error, use the following:
git merge --allow-unrelated-histories frontend-merge
git merge --allow-unrelated-histories backend-merge
Resolve any merge conflicts if they occur. Commit the changes:
git commit -m "Merge frontend-merge and backend-merge into master"
git push origin master
And there you have it! Your GitHub repository's master branch should now contain the combined content and commit history from both frontend and backend repositories.
#git #softwaredevelopment #engineering #ubuntu #programming #softwaredeveloper