Look up the next scheduled codename

Oct 13, 2025 by sorusgentrification.com 49 views

=====================================================

Creating a New Release

To create a new release of vg, we need to follow a series of steps. The first step is to create a new release on GitHub.

Step 1: Create a New Release on GitHub

To create a new release on GitHub, we need to follow these steps:

Look up the next scheduled codename: We need to look up the next scheduled codename in version.cpp. If we have run to the end of the list of codenames, we need to quickly PR some more to master.
Tag it: We need to tag the release with the version number vX.Y.Z.
Title it: We need to title the release with the codename and version number vg X.Y.Z - Codename Here.
Mark it as a prerelease: We need to mark the release as a prerelease.
Publish it: We need to publish the release, which will tag the commit and kick off the Docker build on our Gitlab.

Producing a Buildable Source Tarball

Once we have created the new release on GitHub, we need to produce a buildable source tarball.

Step 1: Create a New Directory

We need to create a new directory to store the source tarball.

mkdir source-tarball
cd source-tarball

Step 2: Clone the Repository

We need to clone the repository using the following command:

git clone --recursive https://github.com/vgteam/vg.git

Step 3: Fetch the Tags

We need to fetch the tags using the following command:

git fetch --tags origin

Step 4: Get the Latest Tag

We need to get the latest tag using the following command:

LATEST_TAG="$(git describe --tags `git rev-list --tags --max-count=1`)"

Step 5: Checkout the Latest Tag

We need to checkout the latest tag using the following command:

git checkout "${LATEST_TAG}"

Step 6: Update the Submodules

We need to update the submodules using the following command:

git submodule update --init --recursive

Step 7: Make the Version

We need to make the version using the following command:

make version

Step 8: Make the Htscodecs Version

We need to make the htscodecs version using the following command:

(cd deps/htslib && make htscodecs/htscodecs/version.h)

Step 9: Remove the Git Directory

We need to remove the Git directory using the following command:

rm -Rf .git

Step 10: Remove the Git Directories in the Dependencies

We need to remove the Git directories in the dependencies using the following command:

find deps -name ".git" -exec rm -Rf "{}" \;

Step 11: Move the Directory

We need to move the directory using the following command:

mv vg "vg-${LATEST_TAG}"

Step 12: Create the Tarball

We need to create the tarball using the following command:

COPYFILE_DISABLE=1 pax -w "vg-${LATEST_TAG}" | gzip -c - >"vg-${LATEST_TAG}.tar.gz"

Step 13: Move the Tarball

We need to move the tarball using the following command:

mv "vg-${LATEST_TAG}" "vg-${LATEST_TAG}.in"

Testing the Tarball

Once we have created the tarball, we need to test it.

Step 1: Extract the Tarball

We need to extract the tarball using the following command:

tar -xf "vg-${LATEST_TAG}.tar.gz"

Step 2: Make the Tarball

We need to make the tarball using the following command:

(cd "vg-${LATEST_TAG}" && make -j$(nproc))

Cleaning Up

Once we have tested the tarball, we need to clean up.

Step 1: Remove the Directory

We need to remove the directory using the following command:

rm -Rf "vg-${LATEST_TAG}" "vg-${LATEST_TAG}.in"

Building and Uploading a Static Linux Binary

Once we have cleaned up, we need to build and upload a static Linux binary.

Step 1: Checkout the Latest Tag

We need to checkout the latest tag using the following command:

git checkout "${LATEST_TAG}"

Step 2: Update the Submodules

We need to update the submodules using the following command:

git submodule sync
git submodule update --init --recursive

Step 3: Remove the Lib Libsdsl.a

We need to remove the lib libsdsl.a using the following command:

rm -f lib/libsdsl.a

Step 4: Sed the Cmake Lists.txt

We need to sed the cmake lists.txt using the following command:

sed -i s/march=native/march=nehalem/ deps/sdsl-lite/CMakeLists.txt

Step 5: Make the Static

We need to make the static using the following command:

CXXFLAGS=" -march=nehalem " make -j$(nproc) static

Step 6: Strip the Vg

We need to strip the vg using the following command:

strip -d bin/vg

Step 7: Test the Vg

We need to test the vg using the following command:

bin/vg test

Creating a New Release on GitHub

Once we have built and uploaded the static Linux binary, we need to create a new release on GitHub.

Step 1: Copy the Description

We need to copy the description of the previous release.

Step 2: Edit the Links and Docker Container Names

We need to edit the links and Docker container names in the description to point to the new release.

Step 3: Insert the Changes

We need to insert the changes from the draft changelog.

Step 4: List the New Dependencies

We need to list the new dependencies.

Step 5: List the Updated, Moved, New, or Removed Submodules

We need to list the updated, moved, new, or removed submodules.

Clearing the Draft Changelog

Once we have created the new release on GitHub, we need to clear the draft changelog for the next release.

Creating a Milestone for the Next Release

Once we have cleared the draft changelog, we need to create a milestone for the next release.

Step 1: Create a New Milestone

We need to create a new milestone using the following command:

gitlab create milestone --title "vX.Y+1.Z" --due-in 6 weeks

Creating an Issue for the Next Release

Once we have created the milestone, we need to create an issue for the next release.

Step 1: Create a New Issue

We need to create a new issue using the following command:

gitlab create issue --title "Release vg vX.Y+1.Z" --assignee "vgteam" --milestone "vX.Y+1.Z"

Updating the Wiki Page

Once we have created the issue, we need to update the wiki page.

Step 1: Update the Wiki Page

We need to update the wiki page using the following command:

gitlab update wiki --title "Releases" --content "vg vX.Y+1.Z - Issue #XXXX - Milestone vX.Y+1.Z"

Building and Uploading a Docker Image

Once we have updated the wiki page, we need to build and upload a Docker image.

Step 1: Build the Docker Image

We need to build the Docker image using the following command:

docker build --target run -t quay.io/vgteam/vg:${VG_VERSION} -f Dockerfile .

Step 2: Push the Docker Image

We need to push the Docker image using the following command:

docker push quay.io/vgteam/vg:${VG_VERSION}

Obtaining the ARM64 Static Binary

Once we have built and uploaded the Docker image, we need to obtain the ARM64 static binary.

Step 1: Pull the Docker Image

We need to pull the Docker image using the following command:

docker pull --platform linux/arm64 "${IMAGE_ID}"

Step 2: Create a New Container

We need to create a new container using the following command:

docker create --platform linux/arm64 "${IMAGE_ID}"

Step 3: Copy the Vg Binary

We need to copy the vg binary using the following command:

docker cp "${CONTAINER_ID}:vg/bin/vg" "./vg-arm64"

Step 4: Remove the Container

We need to remove the container using the following command:

docker rm "${CONTAINER_ID}"

Step 5: Remove the Image

We need to remove the image using the following command:

docker rmi "${IMAGE_ID}"
``<br/>
# Q&A: Release vg v1.65.0
=====================================

## Q: What is the purpose of creating a new release of vg?
A: The purpose of creating a new release of vg is to make the latest version of the software available to users, fix bugs, and add new features.

## Q: What are the steps involved in creating a new release of vg?
A: The steps involved in creating a new release of vg are:

1. Creating a new release on GitHub
2. Producing a buildable source tarball
3. Testing the tarball
4. Cleaning up
5. Building and uploading a static Linux binary
6. Creating a new release on GitHub
7. Clearing the draft changelog
8. Creating a milestone for the next release
9. Creating an issue for the next release
10. Updating the wiki page
11. Building and uploading a Docker image
12. Obtaining the ARM64 static binary

## Q: What is the purpose of producing a buildable source tarball?
A: The purpose of producing a buildable source tarball is to create a package that contains the source code of the software, which can be used to build the software on different platforms.

## Q: How do I produce a buildable source tarball?
A: To produce a buildable source tarball, you need to follow these steps:

1. Create a new directory
2. Clone the repository
3. Fetch the tags
4. Get the latest tag
5. Checkout the latest tag
6. Update the submodules
7. Make the version
8. Make the htscodecs version
9. Remove the Git directory
10. Remove the Git directories in the dependencies
11. Move the directory
12. Create the tarball

## Q: What is the purpose of testing the tarball?
A: The purpose of testing the tarball is to ensure that the software can be built and run correctly on different platforms.

## Q: How do I test the tarball?
A: To test the tarball, you need to follow these steps:

1. Extract the tarball
2. Make the tarball
3. Check if the software can be built and run correctly

## Q: What is the purpose of building and uploading a static Linux binary?
A: The purpose of building and uploading a static Linux binary is to create a package that contains the compiled software, which can be used to run the software on different platforms.

## Q: How do I build and upload a static Linux binary?
A: To build and upload a static Linux binary, you need to follow these steps:

1. Checkout the latest tag
2. Update the submodules
3. Remove the lib libsdsl.a
4. Sed the CMakeLists.txt
5. Make the static
6. Strip the vg
7. Test the vg

## Q: What is the purpose of creating a new release on GitHub?
A: The purpose of creating a new release on GitHub is to make the latest version of the software available to users, fix bugs, and add new features.

## Q: How do I create a new release on GitHub?
A: To create a new release on GitHub, you need to follow these steps:

1. Copy the description
2. Edit the links and Docker container names
3. Insert the changes
4. List the new dependencies
5. List the updated, moved, new, or removed submodules

## Q: What is the purpose of clearing the draft changelog?
A: The purpose of clearing the draft changelog is to remove the changes that have already been included in the new release.

## Q: How do I clear the draft changelog?
A: To clear the draft changelog, you need to follow these steps:

1. Remove the changes from the draft changelog

## Q: What is the purpose of creating a milestone for the next release?
A: The purpose of creating a milestone for the next release is to set a deadline for the next release.

## Q: How do I create a milestone for the next release?
A: To create a milestone for the next release, you need to follow these steps:

1. Create a new milestone
2. Set the deadline for the next release

## Q: What is the purpose of creating an issue for the next release?
A: The purpose of creating an issue for the next release is to track the progress of the next release.

## Q: How do I create an issue for the next release?
A: To create an issue for the next release, you need to follow these steps:

1. Create a new issue
2. Assign the issue to the next release
3. Set the deadline for the next release

## Q: What is the purpose of updating the wiki page?
A: The purpose of updating the wiki page is to keep track of the releases and milestones.

## Q: How do I update the wiki page?
A: To update the wiki page, you need to follow these steps:

1. Update the wiki page with the latest information

## Q: What is the purpose of building and uploading a Docker image?
A: The purpose of building and uploading a Docker image is to create a package that contains the compiled software, which can be used to run the software on different platforms.

## Q: How do I build and upload a Docker image?
A: To build and upload a Docker image, you need to follow these steps:

1. Build the Docker image
2. Push the Docker image

## Q: What is the purpose of obtaining the ARM64 static binary?
A: The purpose of obtaining the ARM64 static binary is to create a package that contains the compiled software, which can be used to run the software on different platforms.

## Q: How do I obtain the ARM64 static binary?
A: To obtain the ARM64 static binary, you need to follow these steps:

1. Pull the Docker image
2. Create a new container
3. Copy the vg binary
4. Remove the container
5. Remove the image