Changes exist upstream in a tracked branch, but when I type git status
it indicates that my local branch is up-to-date. Is this new behavior, did I change a config setting, or is something wrong?
Thanks for the help.
ubuntu@host:/my/repo# git status
On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean
ubuntu@host:/my/repo# git pull
remote: Counting objects: 11, done.
remote: Compressing objects: 100% (11/11), done.
remote: Total 11 (delta 6), reused 0 (delta 0)
Unpacking objects: 100% (11/11), done.
From bitbucket.org:my/repo
1234567..abcdefg master -> origin/master
Updating 1234567..abcdefg
Fast-forward
file1 | 1 -
file2 | 43 +++++++++++++++++++++++++++++++++++++++++++
file3 | 21 ++++++++++++---------
file4 | 21 ++++++++++++---------
4 files changed, 67 insertions(+), 19 deletions(-)
create mode 100644 file5
This question is related to
git
Trivial answer yet accurate in some cases, such as the one that brought me here. I was working in a repo which was new for me and I added a file which was not seen as new by the status.
It ends up that the file matched a pattern in the .gitignore file.
I have faced a similar problem, I searched everywhere online for solutions and I tried to follow them. None worked for me. These were the steps I took to the problem.
Make new repo and push the existing code again to the new repo
git init doesn’t initialize if you already have a .git/ folder in your repository. So, for your case, do -
(1) rm -rf .git/
(2) git init
(3) git remote add origin https://repository.remote.url
(4) git commit -m “Commit message”
(5) git push -f origin master
Note that all git configs like remote repositories for this repository are cleared in step 1. So, you have to set up all remote repository URLs again.
Also, take care of the -f in step 5: The remote already has some code base with n commits, and you’re trying to make all those changes into a single commit. So, force-pushing the changes to remote is necessary.
Let look into a sample git repo to verify if your branch (master)
is up to date
with origin/master
.
Verify that local master is tracking origin/master:
$ git branch -vv
* master a357df1eb [origin/master] This is a commit message
More info about local master branch:
$ git show --summary
commit a357df1eb941beb5cac3601153f063dae7faf5a8 (HEAD -> master, tag: 2.8.0, origin/master, origin/HEAD)
Author: ...
Date: Tue Dec 11 14:25:52 2018 +0100
Another commit message
Verify if origin/master is on the same commit:
$ cat .git/packed-refs | grep origin/master
a357df1eb941beb5cac3601153f063dae7faf5a8 refs/remotes/origin/master
We can see the same hash around, and safe to say the branch is in consistency with the remote one, at least in the current git repo.
While these are all viable answers, I decided to give my way of checking if local repo is in line with the remote, whithout fetching or pulling. In order to see where my branches are I use simply:
git remote show origin
What it does is return all the current tracked branches and most importantly - the info whether they are up to date, ahead or behind the remote origin ones. After the above command, this is an example of what is returned:
* remote origin
Fetch URL: https://github.com/xxxx/xxxx.git
Push URL: https://github.com/xxxx/xxxx.git
HEAD branch: master
Remote branches:
master tracked
no-payments tracked
Local branches configured for 'git pull':
master merges with remote master
no-payments merges with remote no-payments
Local refs configured for 'git push':
master pushes to master (local out of date)
no-payments pushes to no-payments (local out of date)
Hope this helps someone.
"origin/master" refers to the reference poiting to the HEAD commit of branch "origin/master".
A reference is a human-friendly alias name to a Git object, typically a commit object.
"origin/master" reference only gets updated when you git push
to your remote (http://git-scm.com/book/en/v2/Git-Internals-Git-References#Remotes).
From within the root of your project, run:
cat .git/refs/remotes/origin/master
Compare the displayed commit ID with:
cat .git/refs/heads/master
They should be the same, and that's why Git says master
is up-to-date with origin/master
.
When you run
git fetch origin master
That retrieves new Git objects locally under .git/objects folder. And Git updates .git/FETCH_HEAD so that now, it points to the latest commit of the fetched branch.
So to see the differences between your current local branch, and the branch fetched from upstream, you can run
git diff HEAD FETCH_HEAD
This is because your local repo hasn't checked in with the upstream remotes. To have this work as you're expecting it to, use git fetch
then run a git status
again.
in this case use git add and integrate all pending files and then use git commit and then git push
git add - integrate all pedent files
git commit - save the commit
git push - save to repository
Source: Stackoverflow.com