Say a user initiated a git pull on a big, big repo on a remote Windows server. It'll take several minutes to complete. I, another user altogether, remote into the same machine and navigate to that same folder. How can I tell if the other user's git pull is complete?
For context, this folder clones a remote repo to make files available for sharing from it like a CDN. I'm not interested in sharing the machine with another programmer as part of my workflow. I want to know if our file-share has finished updating.
Git is a distributed source control system. The intended use here is for you to git clone the repo on your local machine and work from it. As you finish pieces of work, you can git push to the server. Using a central repo where each developer works on a local one is very common with git. I suggest you do some research on different workflows that are used.
Related
I have two Windows machines that can only connect to each other by Bluetooth. Each has a copy of a git repository on them, possibly with divergent histories.
Obviously, I could just zip up the entire .git folder at one end, send it with fsquirt, then unzip it at the other, and fetch from the local now-bare repository.
But what if I want to only send the contents of the new commits? Can git "pack files" help here?
If git cannot reach the remote filesystem directly through a supported connection protocol, you are essentially looking at what offline options git has. For most purposes, having git create a bundle containing what you need transferred is enough.
git bundle create repo.bundle master
would create a full copy of the current repository in the single file repo.bundle which you can then transfer and use as a read-only repository in the other end. Various options allow you to transfer only parts, but I would recommend against it until you are familiar enough with this to know what you are doing and can find out on your own.
See the Git Book for full instructions: https://git-scm.com/blog/2010/03/10/bundles.html
I've also asked this on reddit, but I'm hedging my bets by asking here as well.
We have an employee who needs to be able to treat a remote non-bare repository as if it's a local one. This employee needs to be able to branch, commit, and merge. There are are a few complications.
Employee is on Windows.
Employee has only surface familiarity with git, and needs to be able to do everything via a friendly GUI.
Employee works from home over a spectacularly flakey internet connection.
I believe that a good solution would involve using sshfs to "localize" the remote repo, allowing any git GUI to treat it as if it's local. But we don't know if this will be compatible with an internet connection that comes and goes periodically, and according to the phase of the moon.
Additionally, the senior engineers would prefer finding a GUI client that has built-in support for administrating remote non-bare repos, rather than doing it with an sshfs "hack". Unfortunately, that would rule out SourceTree, with is the preferred choice of the employee in question.
Really, this is two questions in one:
Is there any reason that sshfs would be unsuitable for a use case with infrequent changes, but a shaky connection?
Are there any git GUI clients for Windows that support this functionality built in?
It looks like we have an alternative solution, that sidesteps the problem entirely with git hooks. I'll just paste in the reddit comment:
It's looking like we're going to end up solving this with git hooks, as follows:
Have bare repos at /srv/git, and non-bare repos in the employee's ~ dir
Employee works in local repo, pushes to remote bare repo
Git hook in remote bare repo does the following:
cd ~name/$repo
git fetch --all
git checkout origin/$branch
Thus, the working dir is always the latest commit of the most recently pushed branch.
For the employee, it's as easy as hitting the "Push" button in SourceTree. All the magic happens on the server.
This might be verbose, but I'm just starting out with git, so I'm still learning here.
Before now, I've had a team of developers all working off of the same hard drive with a local copy of all of our dev files. So we have 1 hard disk and 4 developers. All of us use sublime text and work on the projects together. We all work in the same room, so it's never been an issue to work on the same project at the same time. We just don't work on the same file at the same time. Not the greatest system, but it worked at the time.
Now we want to introduce git to the team for all of the reasons a VCS is important. The problem we're running into is files being locked by one user and no one else can use git on that repository.
Here's an example. I log into my mac in the morning and make some changes to files in Project X located at /Volumes/dev/projectx/. I open terminal and commit those changes to the local repository (stored also at /Volumes/dev/projectx/). My coworker gets in and logs into his mac. He opens up his terminal to check the status on the repo he's working on. So he moves into /Volumes/dev/projectx/ and runs git status. He gets an error message that says the index is locked. In order to allow him to run any git commands on the repo, I have to completely log out (maybe just kill some processes, but I don't know which ones). After I log out, he can work as though there's no problem.
Is there any way that we can both work on the same local repository at the same time?
I've also discovered that, if I'm working in a project that has a git repository in it and anyone else even opens the project folder in a finder window, it completely locks me out from using that git repo (same index lock error).
We're willing to change the way we work on files, but since there are literally thousands of projects on the drive, it isn't really practical for each of us to have our own local copies of all of the files. Also, since many of the changes are a very simple text change of some kind, it seems tedious to host all of these repositories remotely and have to pull down all the files anytime we only want to update a single file.
I'm really looking for workflow suggestions here, but the question I asked is kind of the starting point here.
The whole point of using git is that you don't have to do this kind of crazy stuff.
I know what you've said about why you don't think you should all have complete copies. Here's the hard truth. You're wrong. Mostly. But that's ok, you said your willing to rethink how you work and that's good. Ill try to explain why its not that big a deal to have everyone use their own clones.
A assume all code is already in a remote repository - if its not, sign up on http://github.com or http://bitbucket.com and get a free repository, add it as a remote to your git repo, and push it up. Its really very simple.
Each of your developers should then make their own directory locally on their machines where they can clone the whole repository.
git clone http://github.com/yuoraccount/yourrepo ~/clones/localproject
The first time they clone, it will take a little time to download everything, but from then on, only each minor diff will need to be downloaded uploaded. Git is made to be efficient that way.
When you make a change, commit it, and push it up.
git commit -am "i made a small change"
git push origin master
Then everyone can pull it down.
git pull origin master
You can even all work on different branches, so your not just pushing to the same branch. This should all be really simple, and very easy to do.
You can also split your project into multiple repositories, but you don't really need to. Thousands of files is not a big deal, git can handle it without a problem. That's not to say that you won't have some challenges. Git is easy to use, but you'll eventually run into merge conflicts. They will be a little bit frustrating at first, but stack overflow has a thousand answers explaining how to deal with them - you should be fine.
This is what git is for.
Git is a decentralized version control system. The way you want to use git could be described as the opposite of decentralized.
There are a number of perfectly reasonable workflows possible with git, but all of them are going to involve each developer working in a local clone of some repo.
i guess that your "single harddisk" is really a single "network storage" that can be accessed concurrently. otherwise i don't see the problem (the harddisk can only be attached to a single computer at any time; whenever you unplug the disk, any locks should be released!)
anyhow, though you currently consider it impractical, you still might consider using per-user clones of the repositories.
the normal workflow of a multi-user repository would consist of a local clone of each repository on each developer machine (that is: a clone on your personal mac).
then the trouble with concurrently accessing the locked central repository doesn't exist!
it's exactly the use-case for which git was designed.
this would allow your users to work on the repository even without having access to your central network storage.
if you are concerned about disk-space, you might be happy to hear that git does a pretty decent job of compressing the data (just run git gc every once in a while in your repository).
if (for whatever reasons) you cannot have local copies (on the dev-machine) of the repositories, you might consider having per-user clones on the central storage.
git can use hardlinks for local clones, so disk-space should not be an issue here.
Section 4 of the Pro Git book (version 2) is about "Git on the Server" and gives some information about what the OP is trying to achieve.
The OP's situation calls for the "Local Protocol".
Here is how this works:
1. Create a local remote from your project
cd into your project and create the remote in your preferred location (in your example /Volumes/dev/projectx):
git remote add origin /Volumes/dev/projectx.git
2. Set the permissions for the remote
git init --bare --shared /Volumes/dev/projectx.git
This will set the permissions properly so that different users can push and pull to/from the remote. This command does not affect your Git history and is safe to run.
The --bare flag is used because all that is needed for a remote is a bare repository, that is, a repository without a working directory (a repository with only the .git directory and nothing else).
Note: this step is not described in the Git Book for the Local Remote protocol and is only suggested when setting up a Git server, but in the experience of a colleague, without using this step, the permissions were not set properly.
3. Push the data to your new remote
Assuming you have a branch called main (do this for any branch you want your collaborators to have access to):
git push --set-upstream origin main
4. Have your collaborators clone the remote
This works as with any remote:
git clone /Volumes/dev/projectx.git
From here on, everybody can push and pull to/from the local remote.
I sometimes work in projects where I do development on two computers which are not connected.
A typical example is creating reports in BIDS.
The workflow looks like this:
I create a project/folder in corporate TFS
Use git-tfs to create local git repository
Develop the report and commit to local repository (and some checkins to tfs)
Clone my repository to the customers computer (using vpn/rdp).
Do some development on the customers computer and push/pull with my repository.
(Sometimes the work starts in customer end)
My question is now what to do when I don't have a vpn or rdp connection. I have a temporary ftp I can use but sometimes USB-stick is the only way.
I have looked into format-patch / am but don't understand how I create the initial repository.
Can I just zip the .git folder and unzip in the other end to get started or is there a better way?
format-patch seem to create one file per commit. Is there an easy way to merge/unmerge these?
(It is just me working in the project so I don't branch / rebase)
Github might work in some cases but I don't want to open the can of worms with storing customers data in the cloud.
Yes, you can just copy .git folders around. Once you have two repositories with a common history, you can use git-format-patch and git-am.
But probably better suited for your case is the use of git-bundle. It creates binary bundles that contain the whole history of a branch from which you can fetch and pull. The example in the reference page shows nicely how to use it.
I'm currently working from two different computers on a project - a laptop running Linux, and a desktop running Win7. I'm using an ubuntu server with gitolite on it to host my repos.
I'm trying to write a quick script that will do two things :
Check if anything has changed on the local repo, since the last push. If so, it should commit changes, push the commit to the remote repo
1a. I'm not sure how this works, but I DONT want this commit to overwrite changes in files that I haven't changed locally (ie: they may have been changed on the other computer, and pushed)
After that, it should check if the remote repo has any files that have been changed since my last pull (see 1a.). If so, pull those changes into the local repo.
The intention of this script is to keep both computers synced with each other, without having to manually do all of this git work each time. I would like to have this run periodically (once every half hour?), so I don't want it to take a huge amount of resources, if possible.
I don't need the whole script written for me (unless it is just a couple lines) - just point me towards the commands I will need.
Compare the output of:
git ls-remote <remote>
git show-ref
Although generally what is done is to fetch (not pull) the remote and compare the remote branches with your local branches. If you have non-fast forward merges, you can't really automate because manual intervention on the merge will be required before pushing again.