Using Rugged, I create a new branch from master (let's call it new_branch), modify a file and create a commit for that. Now I want to merge this branch into master, push master to remote and delete new_branch.
At the point of running the code below there are no modified files and no staged files on either branch as the modified is committed into new_branch.
This is the code I use:
from_branch = #repo.head.name
their_commit = #repo.branches[into_branch].target_id
our_commit = #repo.branches[from_branch].target_id
index = #repo.merge_commits(our_commit, their_commit)
if index.conflicts?
# conflicts. deal with them
else
# no conflicts
commit_tree = index.write_tree(#repo)
#repo.checkout(into_branch)
commit_author = { email: GIT_EMAIL, name: GIT_NAME, time: Time.now }
Rugged::Commit.create(#repo,
committer: commit_author,
message: "Merge #{from_branch} into #{into_branch}",
parents: [#repo.head.target, our_commit],
tree: commit_tree,
update_ref: #repo.branches[into_branch].canonical_name)
#repo.push('origin', [#repo.head.name], { credentials: #cred })
#repo.branches.delete(from_branch)
end
This works as expected (modified file is merged into master, it is pushed to remote and the new branch is delete), however once it's done, I am left with the modified file showing under master as modified and staged, ready to be committed while there shouldn't be any modified files in the working directory and nothing staged. Everything should be up-to-date.
In your code you are updating an arbitrary branch, so the index and worktree should not be of concern in the general case.
If you are merging into the current branch, then (and only then) you are missing the steps to update both the index and the worktree with the results of the merge. You can use
#repo.checkout_tree(commit_tree)
to checkout the files as they are on the resulting commit. This will also update the repository's index file to have the contents of that tree. You can then update the current branch to point to the merge commit.
You have a call to #repo.checkout(into_branch) but since you already seem to be in into_branch in your case, that will at best do nothing. You need to checkout the result of the merge, the branch, index or workdir are not touched by the #repo.merge_commits() call.
Related
I have n features branch that will MR and merge into a develop branch.
I have a pipeline with 3 stages:
stages:
- feature-push
- develop-mr-retag
- develop-mr-rollout
feature-push runs on any push to a feature branch (not the develop branch we are merging into). It will test, build, and push an app in a docker image tagged with the name of the feature branch.
The latter two stages should run on commits to a branch develop after a merge request is approved and merged (assuming the source branch passed the feature-push stage). It needs to rollout the new image to some k8s pods, and it needs the name of the source branch to find the correct image.
I want to use ${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME} for this, but I don't think that variable exists for pipelines run after a merge, only on merge_requests pipelines. These seem to be triggered before an MR is approved, which I don't want as this is a deployment.
Is this possible or should I find a different approach?
**Edit: ** To clarify, I need to run my docker build before MR, to know it can build successfully. I don't want to just throw away that build if it's the one that gets merged, so that's why I want to build/push before MR, and deploy the previously built image after MR.
I'm looking for the same.
For the moment, I parse the commit title of the mergecommit to extract the source branch, and I check that the branch found really exist. Here is the relevant code :
CI_MERGE_REQUEST_SOURCE_BRANCH_NAME=$(sed -r "s/^Merge branch '(.*)' into .*/\1/i"<<<$CI_COMMIT_TITLE)
if [ $(git ls-remote --heads ${CI_REPOSITORY_URL} $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME | wc -l ) -ne 1 ]; then echo "Can't find source branche ${CI_MERGE_REQUEST_SOURCE_BRANCH_NAME})" && exit 1; fi
But if the default commit title is modified by anybody, this will not work.
I've created the following rake task below to generate our release notes for each sprint.
I'm pulling in all commits to master older than 2 weeks.
The problem is when a branch has been developed on for more than 2-week sprints, the older commits won't be included.
Can anyone suggest a way I can get these commits in?
task :new_release_note do
puts "Creating new release note"
puts "..."
git_log = `git log --since="two weeks ago" --no-merges --format=%B`
git_log.gsub!(/^$\n/, '')
git_log.gsub!(/^/, "* ")
current_time = DateTime.now
current_date = current_time.strftime "%Y-%m-%d"
current_date_UK = current_time.strftime "%d-%m-%Y"
template = "__Release Notes__
=======================
#{current_date_UK}
__New Features__
----------------
* -
__Improvements__
----------------
* -
__Fixes__
---------
* -
__Change Log__
----------------
Detailed release notes below, listing all commit messages for this release.
#{git_log}
"
out_file = File.new("./doc/release_notes/release-notes-#{current_date}.md", "w")
out_file.puts(template)
if File.exist?(out_file)
puts "New release note generated successfully at /doc/release-notes/release-notes-#{current_date}.md"
else
puts "Error - file not generated."
end
end
Can anyone suggest a way I can get these commits in?
Few options:
git tag
git notes
git whatchanged
git tag
Read this answer on what is git tag and how to use it: What is git tag, How to create tags & How to checkout git remote tag(s)
In short: git tag allows you to mark commit which can be later on to perform your merge. As you know
git pull = git fetch + git merge
So once you have marked your last merge with the tag you can pull out all the changes form the last merge
# "Merge" the last X commits based upon your previous tag
git cherry-pick <tag_name>..master
git notes
git notes allow us to add content to commit without updating the SHA-1 of the commit, meaning we can attach content to the commit while leaving the SHA-1 unmodified.
Now once you have your notes you can find out the last commit which you "merged" previously and grab the changes from this point on using the above cherry-pick.
You can search and find your notes with git log --grep
git whatchanged
Once you what is your referenced commit you can see the list of files which were updated during this time period with the git whatchanged command
# Print out a list of files which was updated/added between the 2 commits
git whatchanged <TAG_NAME>...HEAD
Consider using git tag and tag your releases with version numbers. What my team does is to create a release branch with a version number for each release i.e. release-2.5.8 and when the release is ready, it gets merged into master. Then we tag that merge commit with a version number i.e. v2.5.8 If you do this, along with squash merges then to see all the related commits it's as easy as doing:
git log v2.5.8...v2.5.9
Which will show you all the commits within those 2 releases.
The reason I recommend squash merging your feature branch is for exactly your use case. You want to know what was done during the dev of that feature, but how can you just by date? You really can't. So when your feature is ready to be merged into your release, if you squash merge, you can keep all the notes in a single commit for the merge of that feature. The idea here is you keep what is relevant and discard what is no longer needed during development.
You might also want to check out Gitflow
Using rugged how do you perform the following operations: fetch, pull and rebase?
I am using the development branch and after reviewing its documentation found here as a guide to the Remote class.
EDIT: Since git pull is just a shorthand for git fetch and git merge FETCH_HEAD the better question is how to perform git fetch, git merge and git rebase.
git fetch:
remote = Rugged::Remote.lookup(repo, "origin")
remote.connect(:fetch) do |r|
r.download
r.update_tips!
end
git merge:
merge_index = repo.merge_commits(
Rugged::Branches.lookup(repo, "master").tip,
Rugged::Branches.lookup(repo, "origin/master").tip
)
raise "Conflict detected!" if merge_index.conflicts?
merge_commit = Rugged::Commit.create(repo, {
parents: [
Rugged::Branches.lookup(repo, "master").tip,
Rugged::Branches.lookup(repo, "origin/master").tip
],
tree: merge_index.write_tree(repo),
message: 'Merged `origin/master` into `master`',
author: { name: "User", email: "example#test.com" },
committer: { name: "User", email: "example#test.com" },
update_ref: 'master'
})
git rebase:
Rebasing was not implemented yet in libgit2, and thus is not available in Rugged.
In general, your use case sounds very high level, while the rugged API is currently a bit more focused on low-level git repository access and modification. Eventually, we'll also have many higher-level helpers (like a more simple/correct pull) in the future, but we're not there yet.
The answer above seems to be outdated. The syntax has changed. I need to implement a pull action which i am trying to do by a fetch and then a merge and commit. For fetching i use the fetch method like this
repo.fetch('origin', [repo.head.name], credentials: credits)
And it seems to actually get something since the returned hash is full with information about what has been fetched. However, it is not written to disk. I would expect the branch to be behind several commits when i do git status in the command line but it is not. If i fetch a second time with the same command above then nothing is fetched. This is probably because it has already been fetched the first time but then i dont see where the fetch is.
Now if i go ahead and do the fetch manually in the command line and then try to merge the local copy of the remote branch and the local branch (local changes are already committed) using the following code
ref_name = repo.head.name # refs/heads/branchname
branch_name = ref_name.sub(/^refs\/heads\//, '') # branchname
remote_name = "#{remote}/#{branch_name}" # origin/branchname
remote_ref = "refs/heads/#{remote_name}" # refs/heads/origin/branchname
local_branch = repository.branches[branch_name]
remote_branch = repository.branches[remote_name]
index = repo.merge_commits(local_branch.target, remote_branch.target)
options = {
author: { time: Time.now }.merge(author),
committer: { time: Time.now }.merge(committer),
message: 'merged',
parents: [
local_branch.target,
remote_branch.target
],
tree: index.write_tree(repository),
update_ref: 'HEAD'
}
Rugged::Commit.create repo, options
It creates the commit as expected. The commit is also written to disk and is visible in the fistory. But for some reason the branch has now uncommitted changes. The local file contents have not changed. I would expect them to have the contents of the fetched commit.
Can anyone please provide a working example for a fetch, merge, commit? The version of rugged at time of writing this is 0.22.0b3
Update 1
This will bring my working tree to the wanted state
repo.checkout ref_name, strategy: :force
Update2
I found out how to fetch and save the state to disk
r = repo.remotes[remote]
r.fetch(credentials: git_credentials)
r.save
I created a repo and made some changes into a file. Then I committed and kept working. A couple of changes and I committed again.
I had to go back to the first version, so I did:
hg up 5f01300
And the files from the first version came back.
I made some changes and committed again.
hg commit -m 'Updated'
A new head was created and then I tried:
hg push
Mercurial said there were "outstanding uncommitted" stuffs.
I tried to commit again:
hg commit -m 'Changes accepted'
Then I typed:
hg merge
So a lot of errors appeared because there were two heads and I couldn't merge them.
Sometimes I try to merge like I did above and it works perfectly. Usually at the second time I try to repeat the process, it breaks and I can't merge anything.
Can somebody teach how to merge properly?
[SOME ERRORS]
Usually, at the second time, this is what happens:
int main(int argc, char **argv)
{
printf("hello, world!\n");
<<<<<<< local
printf("sure am glad I'm not using CVS!\n");
=======
printf("sure am glad I'm using Mercurial!\n");
>>>>>>> other
return 0;
}
And I have to do:
hg resolve -m hello.c
Merging is how you combine divergent versions of your files. Whenever you change a file in two different ways, Mercurial will try to merge it when you run hg merge.
When the changes to the files don't overlap, Mercurial can do the merge automatically. However, if you change the same line in two different ways, then you need to help Mercurial merge the two edits.
Consider a file that starts with hello, world! in the first revision and then changes into sure am glad I'm not using CVS! in the second revision:
"hello, world" --- "sure am glad I'm not using CVS!"
You now update back to the first revision and make a different change to the text:
"hello, world" --- "sure am glad I'm not using CVS!"
\
\
\
"sure am glad I'm using Mercurial!"
You now have a divergent history and when you hg merge, Mercurial will tell you that it has detected a conflict in the file. Mercurial will search for a merge tool and if it cannot find any on your system, it will dump the conflicting changes in the file. The file then looks like this:
<<<<<<< local
sure am glad I'm not using CVS!
=======
sure am glad I'm using Mercurial!
>>>>>>> other
The markers you see are called merge markers and they show you the region of the file that couldn't be automatically merged. The top region marked with local is the version you had in your working copy before you typed hg merge. The bottom region marked other is the version that was on the branch you merged with.
Mercurial knows that the file is unresolved and you can see with with hg resolve --list. You now edit the file to somehow combine the two versions. Here's one combination:
sure am glad I'm using Mercurial and not CVS!
I've deleted the merge markers and left behind a version I like. You now mark the file as resolved and commit the merge:
$ hg resolve --mark hello.c
$ hg commit
I hope that helps!
Another comment: You write
[...] I tried: hg push. Mercurial said there were "outstanding uncommitted" stuffs.
Mercurial never talks about uncommitted changes when you try to push. Pushing and pulling are unrelated to your working copy (where your uncommitted changes live). So it is okay to push and pull with a dirty working copy. The error you're thinking of is probably
$ hg merge
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit)
$ hg merge
abort: outstanding uncommitted merges
That is, you cannot start a new merge before you commit or abort the current merge.
I am writing a program in Ruby that necessitates downloading the most current version of my team's software from SVN upon start up.
The checkout function (from the Ruby SVN bindings) is what I believe I want to use, because an update would not ADD any files that do not exist on my machine's local "trunk" workspace. A checkout statement would both update files that do not match to HEAD, and it would download ones that don't exist at all. Effectively, after running a fully recursive checkout, I would hope to have an exact copy of the most recent SVN repository.
According to this API, a checkout statement basically takes the following:
an exact SVN URL
a local root project directory
a revision (I would be using the string 'HEAD')
recursive (integer 1 or 0)
a pool object (I cannot determine what this is for exactly, but I don't think it affects me)
Here's what I wrote, inside a block that iterates for each file in the SVN repository:
if status != NORMAL #any file that changed or is 'missing'
ctx.checkout(status.entry.url, ROOTDIR, 'HEAD', 0, nil) #update abnormal file to HEAD
end
As a test, I erased a directory from my local workspace, and attempted to restore it with this command. It runs through until it reaches one of the missing files, at which point it raises an error:
`svn_client_checkout3': subversion/libsvn_fs_fs/tree.c:663: Svn::Error::FsNotFound: File not found: revision 0, path '/trunk/project-gadfly/SocketServer/DiscoveryServer.cpp' (Svn::Error::FsNotFound)
I do not understand why this error would be raised, because I thought that a checkout statement would see that the directory (i.e. file) does not exist locally and then create it. Perhaps I am doing something wrong?
Looking back on what I've written, I think all of this was a long-winded way of asking the following simple question: How do I get the most current version of SVN repository onto my local hard drive with an SVN Ruby command?
Thanks in advance,
Elwood Hopkins
I don't know about Ruby-specific part of the question, but it's clear that you asked SVN API to checkout "status.entry.url" at revision 0, which of course doesn't exist here.
It's also strange that you looked into Perl documentation for writing in Ruby. I would recommend you to look at Subversion sources instead.
Here's Ruby method declaration:
http://svn.apache.org/repos/asf/subversion/branches/1.7.x/subversion/bindings/swig/ruby/svn/client.rb
def checkout(url, path, revision=nil, peg_rev=nil,
depth=nil, ignore_externals=false,
allow_unver_obstruction=false)
revision ||= "HEAD"
Client.checkout3(url, path, peg_rev, revision, depth,
ignore_externals, allow_unver_obstruction,
self)
end
So as you can see, you've specified 0 as peg revision. But you should specify HEAD instead.
What about pools --- they are parts of SVN memory managements. Here's the explanation: http://subversion.apache.org/docs/community-guide/conventions.html#apr-pools