With yum, every transaction is numbered, so you can rollback the whole system
to a previous state with yum rollback transaction-ID.
I cannot find a way to do a similar thing with zypper, only with Brtfs usage I can manage
to rollback to a previous state with snapper.
Could you please suggest me if there is a way to do a rollback to a previous system state with zypper and ext4 (or other than Brtfs) fs usage?
Thank you in advance!
Related
We were upgrade our liquibase from 1.9.0.0 to 3.6.3. When running migration MD5SUM for 3.6.3 was updated but it was trying to re-run the previously executed changesets which were executed with liquibase 1.9.0.0. How do i run only updating checksum with without re-running the statements.
Thanks.
Liquibase has Command Line Interface. And the CLI has clearCheckSums command.
clearCheckSums clears all checksums and nullifies the MD5SUM column of
the DATABASECHANGELOG table so they will be re-computed on the next
database update.
changesets that have been deployed will have their checksums
re-computed, and pending changesets will be deployed.
Posting a link to the answer on liquibase forums for other users if they encounter the same query ever in future.
I'm totally new with Mercurial.
When commiting and pushing my changes through IntelliJ Idea, I've accidently pushed the Commit and Create MQ patch button.
The commit went through, but push didn't. I force pushed my changes successfully (not a very good thing to do), but I cannot commit anything now.
I get this error:
1 file failed to commit: tip fix. abort: cannot commit over an applied mq patch
The fix was very simple:
I had to type these two commands in IntelliJ Idea terminal:
1. hg commit (with your message commit)
2. hg push
Now everything is back to normal.
If you do a rollback in Heroku it will checkout a previous commit on the Heroku side. We know that. However, how do you restore it to the HEAD commit?
It seems that you actually have to modify your local HEAD, and then push to the repository. Otherwise,
$ git push git#heroku.com:appname.git HEAD:master
Everything up-to-date
and nothing happens, i.e. no new release is created.
The easy solution is just to do some innocuous change like a bundle install, commit, and push. But I was hoping to find someway to bring apps up to the HEAD if they weren't before. Any insight? Am I missing something?
When you do a rollback, you're creating a new deployment to an older change #. The other version is still out there in git. So to go "forward" to the newer change, you'd roll back again, this time to the deployment at that hash number.
I worked on a branch in my Rails app, committed, and merged it into my master, because I was happy with everything, but now I want to take out that branch again and discard those changes.
Is it possible or too late now that I have merged the branch with the master?
Thanks
Once you have pushed commits to a central location, it's best not to modify them in any way.
An alternative is to generate a reverse commit. That is, a commit that undoes all the changes in a previous commit. One way is git-revert. Assuming that you've merged in commits <sha2>, <sha3> and <sha4>, you could:
git revert <sha4>
git revert <sha3>
git revert <sha2>
If you'd like to revert all changes in a single commit, try the --no-commit option:
git revert --no-commit <sha4>
git revert --no-commit <sha3>
git revert --no-commit <sha2>
git commit -m "Undid feature merge"
Another way to generate a single reverse commit is git checkout:
git checkout -f <sha2>
git commit -a -m "Undid feature merge"
You could do a git reset. This is fine if it was only a recent local merge.
If you already pushed the merge somewhere or you have more commits on top, this is no good idea. Instead you have to accept your merge and do a clean git revert. This way the history still contains the merge but the revert will undo the effect of the merge.
In my company we have a subversion server and everyone is using subversion on their machines.
However I'd like to use git, committing changes locally and then "push" them when I'm ready.
However, I can't understand what happens in the following situation.
Let's say that I made 3 git commits locally and now I'm ready to "push" everything on the subversion server. If I understand correctly, git svn dcommit should basically make 3 commits sequentially on the server, right? But what happens if in the meantime (let's say between the second and the third commit) another colleague of mine issues a commit?
The scenarios I can think of are:
1) git kind of "locks" (is that even possible?) the subversion server during commits so that my commits are doing atomically and my colleague's one is done after mine
2) The commit history on the server becomes mine1-mine2-other-mine3 (even if 'other' should fail since my colleague doesn't have an updated working copy at that point).
I think it's #2, but perhaps the committing speed is so high that this seldom becomes an issue. So which one is, #1 or #2?
No locks are not supported in Git, it's not a Git way (Git way is branching and merginig).
With git-svn you'll get mine1-mine2-other-mine3 history. If you need atomicity, have a look at SubGit project (it is installed into the SVN server and creates a pure Git interface for the SVN repository).
There was a similar question recently that might be interesting for you.
If you are lucky then number 2 but most of the time you aren't that lucky. In my experience when I dcommit a lot of commits and someone else commits while doing that usually 2 things happen:
It stops with dcommitting your other changes.
You lose the commits not-yet dcommitted.
Number 2 is really really annoying. The main problem is that you need to be totally up-to date to use git svn dcommit. This is because git-svn doesn't let the server merge revisions on the fly. (Because it would require both committers to have a working tree with both changes).
The only way to solve this are the following steps which I found here
Open .git/logs/HEAD
Look for your most recent commit (note that these commits are sorted
by “unix time”, although you can also find the latest one by reading
the shortlog there
Confirm that the commit you found is the right one: git show
git reset --hard hash from log
git svn rebase
git svn dcommit
Following this procedure allows you to take off from where it failed. I hope they fix this soon but they said this isn't priority for them yet.
Ofcourse if you commmit small groups and have a fast connection to the server it shouldn't happen that often. (I only got it 2-3 times when actively working and committing every day for 6 months).