Difference between revisions of "Release Process"

From Einstein Toolkit Documentation
Jump to: navigation, search
Line 455: Line 455:
 
release:
 
release:
  
  PREVRELEASEMONTH=11
+
<pre>
  PREVRELEASEYEAR=2020
+
#/bin/bash
  FORMAT="%h %ae %an: %s"
+
PREVRELEASEMONTH=05
  ####
+
PREVRELEASEYEAR=2022
  TAG="ET_${PREVRELEASEYEAR}_${PREVRELEASEMONTH}_v0"
+
FORMAT="%h %ae %an: %s"
  DATE="${PREVRELEASEMONTH}/01/${PREVRELEASEYEAR}"
+
####
  for i in repos/*/.git
+
TAG="ET_${PREVRELEASEYEAR}_${PREVRELEASEMONTH}_v0"
  do
+
DATE="${PREVRELEASEMONTH}/01/${PREVRELEASEYEAR}"
    export GIT_DIR=$i
+
for i in repos/*/.git
    echo "CHANGES FOR $(dirname $i)"
+
do
    git fetch --tags 1>/dev/null 2>/dev/null
+
  export GIT_DIR=$i
    git log ${TAG}..master --format="$FORMAT" 2>/dev/null
+
  DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')
    E=$?
+
  echo "CHANGES FOR $(dirname $i)"
    if [ $E != 0 ]
+
  git fetch --tags 1>/dev/null 2>/dev/null
    then
+
  git log --format="$FORMAT" ${TAG}..${DEFAULT_BRANCH} -- 2>/dev/null
      echo " >> TAG ${TAG} missing for repo, using date."
+
  E=$?
      git log $(git rev-list -n 1 --before="${DATE} 00:00" master)..master --format="$FORMAT"
+
  if [ $E != 0 ]
    fi
+
  then
  done
+
    echo " >> TAG ${TAG} missing for repo, using date."
 +
    git log --format="$FORMAT" $(git rev-list -n 1 --before="${DATE} 00:00" ${DEFAULT_BRANCH})..${DEFAULT_BRANCH} --
 +
  fi
 +
done
 +
</pre>
  
 
Note that when analyzing the output from the *nrpytutorial/* repo, you'll need to be careful to only check for changes to NRPyPN; all other changes are not ET related.
 
Note that when analyzing the output from the *nrpytutorial/* repo, you'll need to be careful to only check for changes to NRPyPN; all other changes are not ET related.

Revision as of 19:30, 20 October 2022

Release Process

This page describes the release process in some detail. Getting a release out of the door without embarrassing oversights requires a bit more planning and care than one would like.

Timeline for a release and estimated time required

  1. Form a release coordination team (6 months) (part of ET calls)
    1. a release coordinator
    2. a release coordinator assistant, who may be the release coordinator for the next release
    3. the former release coordinator to help out
    4. test runner(s) who will run the testsuites on the list of supported machines
    5. example runner volunteer(s) for gallery examples
  2. Come up with release timeline (by translating the last release timeline forward in time), see (5 months) (30 minutes), see https://docs.einsteintoolkit.org/et-docs/Release_Details#Schedule_for_ET_2020_05
    1. Release coordinator needs write access to the following repos (or must arrange all needed changes with a repo maintainer)
      1. https://bitbucket.org/einsteintoolkit
      2. https://github.com:nds-org/jupyter-et.git
      3. https://svn.cct.lsu.edu/repos/numrel/simfactory2/www/
    2. Frequently remind participants of timeline (part of ET calls)
    3. Begin discussions on the mailing list, reminding people to look at test cases, review patches etc. (5 minutes per week)
  3. Choose features which are going to be included, and those which won't be included (4 months)
    1. ask for review volunteers, assign tasks to people (part of ET calls) e.g. https://docs.einsteintoolkit.org/et-docs/Meeting_agenda#2020-09-10
    2. create tickets for each proposed item on https://trac.einsteintoolkit.org eg. https://bitbucket.org/einsteintoolkit/tickets/issues/2416
    3. Decide on a list of release-critical compute systems eg XSEDE, LCCF, DOE, PRACE: http://einsteintoolkit.org/testsuite_results/index.php
      1. get accounts for test runners
  4. Drive review of thorns for code quality, documentation, test cases (continuously)
    1. Include positively reviewed and voted on items in main ET repositories
    2. Remove new features without reviewer or negatively reviewed from list of new features
    3. Frequently remind participants of timeline
  5. Start testing on release-critical compute systems (2 months) (30 minutes per week per cluster to compile, run, check, upload)
    1. initially test to make sure clusters can still build code
    2. test code as they become positively reviewed (code is present in master before final positive review)
    3. report on test failures
    4. assign found bugs to volunteers
  6. Release preparation I (4 weeks)
    1. Announce feature freeze based on currently positively reviewed components
    2. Collect list of new features, newsworthy items, and acknowledgements for release announcement on wiki (there’s a script in the wiki to help with this) (45 minutes)
    3. Contact contributors and example runners about permanent (contributors) and one-off (example runners) inclusion in the ET author list (10 minutes of work per author to poke and prod them to respond)
    4. Draft release announcement (1 hour)
      1. send to maintainers@einsteintoolkit.org for review re typos etc.
    5. Announce release date publicly
  7. Release preparation II (1 week), detailed list of items and partial scripts on https://docs.einsteintoolkit.org/et-docs/Release_Process#Two_weeks_before_the_release
    1. Finalize announcement draft (1 hour)
      1. Send to maintainers@einsteintoolkit.org for review re typos etc.
    2. Create Zenodo item (see link above) (1 hour)
      1. Send to maintainers@einsteintoolkit.org for review re typos etc.
    3. Update einsteintoolkit.bib (https://bitbucket.org/einsteintoolkit/manifest/src/master/) with
      1. Update or add requested and suggested citations for all ET components in thorn list (10 minutes).
      2. Latest release info and DOI (from Zenodo entry above)
    4. Create release branch and tag for all ET codes (30 minutes)
    5. Update version information in Makefile, the documentation tex files and Baikal documentation.tex file (15 minutes)
    6. Regenerate all auto-generated files (30 minutes of work, plus time to wait for Kranc)
    7. Update websites in a branch (2 hours)
      1. EinsteinToolkit.org (https://docs.einsteintoolkit.org/et-docs/Editing_the_Einstein_Toolkit_website ; be sure to update the main page; then about/releases/ET_202X_YZ_announcement.md; then from that directory run `mk_release_announcements.py ET_202X_YZ_announcement.md` [you'll need to `pip install markdown` for this to work]; then be sure to `git add` and commit the new files.)
      2. CactusCode.org (https://github.com/einsteintoolkit/www.cactuscode.org, see below for a script.
      3. Simfactory.org (https://svn.cct.lsu.edu/repos/numrel/simfactory2/www/)
      4. CactusTutorial.ipynb (https://github.com:nds-org/jupyter-et.git)
  8. The release (0 days)
    1. make all updated branches live (30 min)
    2. announce on users@einsteintoolkit.org, news@cactuscode.org (5 min)
    3. http://hyperspace.uni-frankfurt.de/ based on previous release announcement (15 min)
    4. update Wikipedia Cactus entry https://en.wikipedia.org/wiki/Cactus_Framework (5 min)
    5. Run the testsuite using the release code on all supported machines (30 min per cluster)
    6. Update https://docs.einsteintoolkit.org/et-docs/Release_Process with lessons learned (30 minutes)

Helpful tools and notes

This section collects a handful of useful commands that may become critical to guarantee the quality of the release. The descriptions below are quite technical and intended for the developers and maintainers only.

update developers.txt

Inside https://bitbucket.org/einsteintoolkit/www/src/master/ , you will find a developers.txt file, which needs to be updated with any new developers for this release. Any developers who helped with the last release but have not yet contributed code to the Toolkit need to be removed, and likewise any new folks who contributed to this release need to be added.

Here is a script for finding contributers to the release. You will need this for the release announcement also.

{
for repo in */.git
do
      (cd $repo && git shortlog $(git describe --tags --abbrev=0)..HEAD --summary --email) | perl -p -e 's/^\s*\d+\s*//'
done
} | sort -u

After updating, run

 developers.py

Next, update zenodo.py. It contains the hard-coded information in between the EDIT BELOW and EDIT ABOVE tags.

 release_team = [
   "Zachariah B. Etienne",
   "Roland Haas",
   "Steven R. Brandt",
   "William E. Gabella",
   "Peter Diener",
   "Atul Kedia",
   "Miguel Gracia",
   ...
 ]
 contributers = [
   "Roland Haas",
   "Steven R. Brandt",
   ...
 ]
 et_release = "ET_2021_05"
 et_release_codename = "Lorentz"
 et_description = ...

Publish to the sandbox (following the steps below). Once that is done and reviewed, it can be published without --sandbox.

drafting Zenodo entry

# get Steve Brandt's personal access token for zenodo.org
# create your own personal access token for sandbox.zenodo.org:
# https://sandbox.zenodo.org/account/settings/applications/tokens/new/
export ZENODO_ACCESS=STEVES_ZENODO_ACCESS_TOKEN
export SANDBOX_ZENODO_ACCESS=YOUR_ZENODO_SANDBOX_ACCESS_TOKEN

# note down ID of "Einstein Toolkit" (will change each release)
ZENODO_ID=$(python3 ./zenodo.py --list | perl -n -e '/(\d*) The Einstein Toolkit/ && print ($1) && exit 0')

# This will generate Definition.md and zupload.py (metadata)
python3 ./zenodo.py --id $ZENODO_ID --generate

# recreate current release in sandbox, note that zenodo.py will use
# SANDBOX_ZENODO_ACCESS token and sanbox.zenodo.org when --sandbox is used.
python3 ./zenodo.py --sandbox --create zupload.py

# note down ID of newest (topmost) "Einstein Toolkit"
ZENODO_SANDBOX_ID=$(python3 ./zenodo.py --sandbox --list | perl -n -e '/(\d*) The Einstein Toolkit/ && print ($1) && exit 0')

# publish current release in sandbox
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --deposit Definition.md
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --publish

# now we make the new release

# Edit the lines in zenodo.py that are between the Edit Below/Edit Above comments.
# This includes the release, the code name, the release team, etc.
vi zenodo.py

# This will generate Definition.md and zupload.py (metadata)
rm Definition.md zupload.py
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --generate

# create a new version in sandbox
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --newversion

# note down ID of newest (topmost) "Einstein Toolkit"
ZENODO_SANDBOX_ID=$(python3 ./zenodo.py --sandbox --list | perl -n -e '/(\d*) The Einstein Toolkit/ && print ($1) && exit 0')

# upload updated metadata (zenodo.py)
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --upload

# deposit updated dummy file
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --deposit Definition.md
# publish new version (cannot be undone)
python3 ./zenodo.py --sandbox --id $ZENODO_SANDBOX_ID --publish

# create a new version in real Zenodo but *do not* publish (yet)
python3 ./zenodo.py --id $ZENODO_ID --newversion

# note down ID of newest (topmost) "Einstein Toolkit"
ZENODO_ID=$(python3 ./zenodo.py --list | perl -n -e '/(\d*) The Einstein Toolkit/ && print ($1) && exit 0')

# generate metadata for actual Zenodo (different DOI!)
rm Definition.md zupload.py
python3 ./zenodo.py --id $ZENODO_ID --generate

# upload updated metadata (zenodo.py)
python3 ./zenodo.py --id $ZENODO_ID --upload

# deposit updated dummy file
python3 ./zenodo.py --id $ZENODO_ID --deposit Definition.md

# get reserved DOI to use in bibtex file
python3 ./zenodo.py --id $ZENODO_ID --show-doi

Send the Zenodo entry from the sandbox to <a href="mailto:maintainers@einsteintoolkit.org">maintainers@einsteintoolkit.org</a> for proofreading, include in "do you want to be included" email to contributors.

final Zenodo entry

This replicates the latter steps of the draft to create a new entry on the real Zenodo site. Do so *only* after the draft has been reviewed since it cannot be undone.

export ZENODO_ACCESS=STEVES_ZENODO_ACCESS_TOKEN

# note down ID of newest (topmost) "Einstein Toolkit"
ZENODO_ID=$(python3 ./zenodo.py --list | perl -n -e '/(\d*) The Einstein Toolkit/ && print ($1) && exit 0')

# publish new version (cannot be undone)
python3 ./zenodo.py --id $ZENODO_ID --publish

update version information

  • update version information in flesh/Makefile in the CCTK_VERSION_XXX variables
  • update version information in flesh/doc/latex.sty in the \cactustitlepage command
export CCTK_VERSION=Cactus_4.X.0
CCTK_VERSION_MINOR=$(echo $CCTK_VERSION | cut -f2 -d.)
sed -i "s/CCTK_VERSION_MINOR = .*/CCTK_VERSION_MINOR = $CCTK_VERSION_MINOR/" Makefile
sed -i 's/\\cactustitlepage}\[4\]\[4\..*\]/\\cactustitlepage}[4][4.'$CCTK_VERSION_MINOR']/' doc/latex/cactus.sty
git add Makefile doc/latex/cactus.sty
git commit -m 'Cactus: update version in information in Makefile and docs'
  • update wvuthorns/Baikal/doc/documentation.tex and wvuthorns/BaikalETK/doc/documentation.tex with git hash of nrpytutorial used to generate code. The hash is mentioned in the README file. To compare codes, check out https://github.com/zachetienne/nrpytutorial.git at the hash in question and generate using ./run_Jupyter_notebook.sh Tutorial-BaikalETK.ipynb. In ET_2020_05 this required forcing python3. The generated code lacks using CCTK_REAL for non-vectorized code, and the order in which finite difference orders are checked and included is timing dependent and thus random.

regenerate files

  • regenerate McLachlan, WeylScal4, CTThorns, and EinsteinExact from their source with the current version of Kranc by running make -j NJOBS in their respective m directory.
  • check that BaikalVaccum and Baikal can be regenerated using the nrpytutorial hash lised in their README file using python3 BaikalETK/BaikalETK_main_codegen_driver.py
  • Next run the following script, which
    • generates the Cactus configure script by running autoconf2.13 in lib/make
    • generates the Cactus loop macros by running perl cctk_Loop.h.pl in src/include
    • generates UsersGuide, ReferenceManual and MaintGuide pdf files by running make UsersGuide ReferenceManual MaintGuide
cd lib/make
autoconf2.13
git add configure 
git commit -a -m 'Cactus: regenerate configure' || true
cd ../../src/include
perl cctk_Loop.h.pl
git commit -a -m 'Cactus: regenerate cctk_Loop.h' || true
cd ../../
make UsersGuide ReferenceManual MaintGuide
cd doc
git add MaintGuide.pdf ReferenceManual.pdf UsersGuide.pdf
git commit -a -m 'Cactus: regenerate documentation' || true

create branches

  • Important! Before this step, add the new bibtex entry to einsteintoolkit.bib in https://bitbucket.org/einsteintoolkit/manifest.git
  • Create release branches for all repositories in the ET
    • A new ET branch ET_YYYY_MM
    • A new ET tag ET_YYYY_MM_v0
    • A new Cactus branch Cactus_4.X.0 if in CactusCode
    • A new Cactus tag Cactus_4.X.0_v0 if in CactusCode
#!/bin/bash
# This script is run from inside the repos directory
export ET_RELEASE=ET_XXXX_YY
export CCTK_VERSION=Cactus_4.X.0
set -x -e
set -x -e
for repo in */.git ; do
  cd $repo/..
  pwd
  if git branch -a | grep -q origin/$ET_RELEASE ; then
    echo "Already pushed"
    cd - >/dev/null
    continue
  fi
  default_branch=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')
  repo_name=$(basename $PWD)
  git checkout $default_branch
  git checkout -b $ET_RELEASE
  if [ $repo_name = manifest ] ; then
    sed -i "/!DEFINE  *COMPONENTLIST_TARGET/a \\\\n!DEFINE ET_RELEASE = $ET_RELEASE" einsteintoolkit.th
    sed -i '/!URL/a \!REPO_BRANCH = $ET_RELEASE' einsteintoolkit.th
    sed -i 's!/trunk!/branches/$ET_RELEASE!' einsteintoolkit.th
    git add einsteintoolkit.th
    git commit -m 'einsteintoolkit.th: use release branch'
  fi
  git tag ${ET_RELEASE}_v0
  git push --tags --set-upstream origin $ET_RELEASE
  if git remote get-url origin | grep cactuscode ; then
    git branch $CCTK_VERSION
    git tag ${CCTK_VERSION}_v0
    git push --tags --set-upstream origin $CCTK_VERSION
  fi
  cd - >/dev/null
  sleep 5 # bitbucket enforces some rate limit on pushes its seems
done
export ET_RELEASE=ET_XXXX_YY
git checkout -b $ET_RELEASE
sed -i "s/master/$ET_RELEASE/" .gitmodules
git add .gitmodules
git submodule foreach bash -c "git fetch origin '+refs/heads/*:refs/remotes/origin/*'; git checkout origin/$ET_RELEASE"
git commit -am "Create release branch for $ET_RELEASE"

update websites and online documentation

https://docs.einsteintoolkit.org/et-docs/Editing_the_Einstein_Toolkit_website

  • Update main ET web site (update version numbers, urls), searching for ET_YYYY_MM finds them all
#!/bin/bash

set -e -x

export EDITOR=vim

export ET_RELEASE=ET_2020_05
export PREVIOUS_ET_RELEASE=ET_2019_10

export ET_RELEASE_CODENAME=Turing
export PREVIOUS_ET_RELEASE_CODENAME=Mayer
export ET_RELEASE_CODENAME_FULL="Alan Turing"

export ET_RELEASE_URL="https://en.wikipedia.org/wiki/Alan_Turing"
export PREVIOUS_ET_RELEASE_URL="https://en.wikipedia.org/wiki/Maria_Goeppert_Mayer"

export ET_RELEASE_DATE="May 31st, 2020"
export ET_RELEASE_DATE_ISO=2020-05-31

ALL_FILES=$(git grep -l "\($PREVIOUS_ET_RELEASE\|$PREVIOUS_ET_RELEASE_CODENAME\)"  | grep -v 'about/releases/' | grep -vF past-releases.html | grep -vF publications/2013_MHD/index.php | grep -vF developers. | grep -vF members.txt | grep -vF mp.html) 

# update URL first since it tends to include the release codename
sed -i "s!$PREVIOUS_ET_RELEASE_URL!$ET_RELEASE_URL!g" index.html

# update release names
sed -i "s/$PREVIOUS_ET_RELEASE/$ET_RELEASE/g" $ALL_FILES
sed -i "s/$PREVIOUS_ET_RELEASE_CODENAME/$ET_RELEASE_CODENAME/g" $ALL_FILES

# release date
sed -i "s/[(]released on [^)]*[)]/(released on $ET_RELEASE_DATE)/g" download.html

# update past reelases, mark this one as most recent
# TODO: use something other than sed for this
sed -i -e '/List of Einstein Toolkit releases:/{n;b add_release}' -e 'b end' -e ':add_release;a\
          <li>'$ET_RELEASE' "'"$ET_RELEASE_CODENAME_FULL"'", <a href="about/releases/'$ET_RELEASE'_announcement.html">released '$ET_RELEASE_DATE_ISO'</a>\
          </li>' -e ':end' past-releases.html

# add news item to front page
$EDITOR index.html

git diff

git add $ALL_FILES past-releases.html download.html index.html
git commit -m "update to $ET_RELEASE"

echo 'Use git show and git commit --amend to correct mistakes'
sed -i "s/$PREVIOUS_ET_RELEASE/$ET_RELEASE/g" simfactory/download/index.php
sed -i "s/$PREVIOUS_ET_RELEASE/$ET_RELEASE/g" CactusTutorial.ipynb

From the https://github.com/nds-org/jupyter-et repo, do the following

cd tutorial-server
touch variables.env
docker-compose -f docker-compose.base.yml build --no-cache --pull
for c in notebook cilogon cyol
do
    docker-compose -f docker-compose.$c.yml build
    docker-compose -f docker-compose.$c.yml push
done

The tutorial server at https://etk.cct.lsu.edu checks for a new image once a day.

  • To update cactuscode.org: git clone git@github.com:EinsteinToolkit/www.cactuscode.org.git
#!/bin/bash

set -e -x

PREVIOUS_ET_RELEASE=ET_2021_11
ET_RELEASE=ET_2022_05

PREVIOUS_ET_ITER=twenty-third
ET_ITER=twenty-fourth

PREVIOUS_CACTUS_VERSION=4.11.0
CACTUS_VERSION=4.12.0

PREVIOUS_ET_WIKIPEDIA="Katherine_Johnson"
ET_WIKIPEDIA="Bernhard_Riemann"

PREVIOUS_ET_NAME="Johnson"
ET_NAME="Riemann"


ET_DATE="$(date +"%B %d, %Y")"
AUTHOR="$(git config --get user.name)"

cd media/news

# keep the mkdir below to so that it fails if the output directories already
# exist

mkdir $ET_RELEASE
cp -a $PREVIOUS_ET_RELEASE/* $ET_RELEASE/
sed -i "s!/$PREVIOUS_ET_WIKIPEDIA!/$ET_WIKIPEDIA!g" $ET_RELEASE/index.md
sed -i "s!$PREVIOUS_ET_NAME!$ET_NAME!g" $ET_RELEASE/index.md
sed -i "s!$PREVIOUS_ET_ITER!$ET_ITER!g" $ET_RELEASE/index.md
sed -i "s!^### .*!### $ET_DATE $AUTHOR!" $ET_RELEASE/index.md

mkdir cactus_$CACTUS_VERSION
cp -a cactus_$PREVIOUS_CACTUS_VERSION/* cactus_$CACTUS_VERSION/
sed -i "s!${PREVIOUS_CACTUS_VERSION//./[.]}!$CACTUS_VERSION!g;" cactus_$CACTUS_VERSION/index.md
sed -i "s!/$PREVIOUS_ET_WIKIPEDIA!/$ET_WIKIPEDIA!g" cactus_$CACTUS_VERSION/index.md
sed -i "s!$PREVIOUS_ET_NAME!$ET_NAME!g" cactus_$CACTUS_VERSION/index.md
sed -i "s!^### .*!### $ET_DATE $AUTHOR!" cactus_$CACTUS_VERSION/index.md

NEWS="$(<../../_data/news.yml)"
cat >../../_data/news.yml <<EOF
- date: "$ET_DATE"
  link: "$ET_RELEASE/index.html"
  title: 'Einstein Toolkit "$ET_NAME" Release'
- date: "$ET_DATE"
  link: "cactus_$CACTUS_VERSION/index.html"
  title: 'Cactus $CACTUS_VERSION Release'
$NEWS
EOF

release anouncement issues

On einsteintoolkit.org

  • ThornGuide.php is in /www/einstein/www/documentation
  • It draws on the autogenerated http doc files, which are found here:
 /var/www/einstein/documentation
 docker build --no-cache -f etk-website.docker -t stevenrbrandt/etk-website .
 docker push stevenrbrandt/etk-website

Other stuff

Changes to announce

First grab the latest dev version:

 curl -kLO https://raw.githubusercontent.com/gridaphobe/CRL/master/GetComponents
 chmod a+x GetComponents
 ./GetComponents --parallel https://bitbucket.org/einsteintoolkit/manifest/raw/master/einsteintoolkit.th


Then in that directory, the following script may be helpful in figuring out what has changed since the last release:

#/bin/bash
PREVRELEASEMONTH=05
PREVRELEASEYEAR=2022
FORMAT="%h %ae %an: %s"
####
TAG="ET_${PREVRELEASEYEAR}_${PREVRELEASEMONTH}_v0"
DATE="${PREVRELEASEMONTH}/01/${PREVRELEASEYEAR}"
for i in repos/*/.git
do
  export GIT_DIR=$i
  DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@')
  echo "CHANGES FOR $(dirname $i)"
  git fetch --tags 1>/dev/null 2>/dev/null
  git log --format="$FORMAT" ${TAG}..${DEFAULT_BRANCH} -- 2>/dev/null
  E=$?
  if [ $E != 0 ]
  then
    echo " >> TAG ${TAG} missing for repo, using date."
    git log --format="$FORMAT" $(git rev-list -n 1 --before="${DATE} 00:00" ${DEFAULT_BRANCH})..${DEFAULT_BRANCH} --
  fi
done

Note that when analyzing the output from the *nrpytutorial/* repo, you'll need to be careful to only check for changes to NRPyPN; all other changes are not ET related.

This misses changes in subversion repositories, currently only in ExternalLibraries which can be queried manually using svn log and usually contain very few changes.

This misses new repositories (or at best only considers recent changes to them).

creating release branches (outdated version control systems)

    • svn: svn copy https://<repository-server>/<repository-path>/trunk https://<repository-server>/<repository-path>/branches/ET_2011_05
    • darcs: clone the repository, appending a suffix to the name
    • git: git checkout -b ET_2011_05 ; git push --set-upstream origin ET_2011_05