# Merge with git instead of github UI

If someone sends patches by email apply them on top of latest master, and
push to upstream.  Github pull requests are best to get as extra remote
repositories to your working clone, where commits can be rebased, tidied up,
and so on, before pushing to upstream.

See also https://github.com/iputils/iputils/issues/155

# Do not steal contributions

Use git commit --author 'Contributor <email>' when receiving changes that
are not applicable as-is.  Not stealing contributions applies even if change
has to be worked out, that is common case with commit message.

Exception to this rule is a change that is a good idea, but has to be
completely rewrote to be acceptable for the project.  In this case
maintainer should attribute the person who gave the idea in commit message.

# Use references in commit messages

For example when a change fixes a distribution bug add link to the bug
report.  Links to reference materials can also be useful when in future
trying to understand why something was done.  It is also nice when commit id
of the change that caused a bug is referred in commit message.  That helps
understanding what versions are impacted by an issue.

# How to make a release

Go to release listings https://github.com/iputils/iputils/releases and check
what was said in previous release message.  Draft release message - remember
if you have nothing to say then you don't have good enough reason to publish
release.

Update 'iputils.pot' and translated po files (use 'tools/update-po-files.sh'
script) and push this change and ask translators to update translations.

Update CHANGES file. It should list the most notable changes and important or
security related fixes. Create pull request with these changes to give people
chance to review and test upcoming release. Notify distro maintainers, ask
community for testing.

NOTE: There is 'tools/tag-release.sh' script, which automates the following
steps of tagging git (it does also various sanity checks).

Create release commit and tag.

    tag="$(date +%Y%m%d)"
    sed --in-place "s/version : '.*')/version : '$tag')/" meson.build
    git add meson.build CHANGES
    git commit -S --signoff --message "release: iputils-$tag"
    git tag --sign --annotate $tag --message iputils-$tag

Check that the commit and tag looks ok.

    git show $tag --show-signature

Assuming things are great push to github.

    git push origin master:master
    git push origin $tag

Go to github https://github.com/iputils/iputils/releases and paste
the content of CHANGES file for upcoming release to the text box.
Add there also credit for all contributors.
NOTE: 'tools/create-tarballs.sh' script creates also skeleton of the credit.

    Many thanks to the people contributing to this release:

    old_tag="$(git describe --abbrev=0 $tag^)"
    git shortlog -sen $old_tag..

    Also thanks to patch reviewers:

    git log $old_tag.. | grep -Ei '(reviewed|acked)-by:' | sed 's/.*by: //' | sort | uniq -c | sort -n -r

    and testers:

    git log $old_tag.. | grep -Ei 'tested-by:' | sed 's/.*by: //' | sort | uniq -c | sort -n -r

Create release tarballs (tar.xz, tar.gz and zip) and checksums with
'tools/create-tarballs.sh' script. Run it with a reasonably new meson
to avoid failures on old version (see minimal version in the file).

NOTE: github also produces tar.gz and zip files. We consider them unsecure, do
not recommend to use them and don't produce checksums for it.
Choose the tag you just created.  Download the release files, compute sha256 hash:

The release should be ready.  People tend to react to releases, so expect bug
reports and pull requests after release.  Assuming release has fatal flaw(s)
make another one sometime soon.

# Maintainers' GPG public keys

All maintainers' GPG public keys used for signing tags, releases, commits, etc.
are stored in Documentation/project-keys.gpg. When adding new maintainer, add
his/her key into 'tools/update-project-keyring.sh', run it to update keyring and
push the result.

# Branches in git

The upstream repository has exactly one branch and it is 'master'.  If a
maintainer wants to use work in progress branches they need to be kept in
personal clone.  There are two reasons to do this.  For contributors it is
nice not to see random branches when cloning upstream repo.  Secondly when
maintainer wants to add a contributor repo as additional remote it is easier
to see what is going on there.