tools: Port make-version.pl to Python

This commit is contained in:
Moshe Kaplan 2022-07-11 14:44:23 +00:00 committed by AndersBroman
parent b53044ea16
commit 87ca8c227a
12 changed files with 466 additions and 706 deletions

2
.gitattributes vendored
View File

@ -5,5 +5,5 @@
.gitattributes export-ignore
.gitignore export-ignore
.gitreview export-ignore
tools/make-version.pl export-subst
tools/make-version.py export-subst
packaging/source/git-export-release.sh.in export-subst

View File

@ -143,7 +143,7 @@ variables:
- git config --global user.name "Your Name"
- mkdir build
- cd build
- perl ../tools/make-version.pl --set-release
- python3 ../tools/make-version.py --set-release ..
- mv -v ../wireshark-*.tar.* .
artifacts:
paths:
@ -185,7 +185,7 @@ Source Package:
stage: .pre
rules: !reference [.if-merged]
script:
- perl ../tools/make-version.pl --set-release || ../perl make-version.pl --set-release
- python3 ../tools/make-version.py --set-release ..
- printf "\e[0Ksection_start:%s:cmake_section[collapsed=true]\r\e[0KRunning CMake" "$( date +%s)"
- cmake -G Ninja $CMAKE_ARGS -DENABLE_CCACHE=ON ..
- printf "\e[0Ksection_end:%s:cmake_section\r\e[0K" "$( date +%s)"
@ -208,7 +208,7 @@ Debian Stable APT Package:
image: registry.gitlab.com/wireshark/wireshark-containers/debian-stable-dev
script:
- ln --symbolic --no-dereference --force packaging/debian
- perl tools/make-version.pl --set-release
- python3 tools/make-version.py --set-release .
# Shared GitLab runners limit the log size to 4M, so reduce verbosity. See
# https://gitlab.com/gitlab-com/support-forum/issues/2790
- export DH_QUIET=1
@ -330,7 +330,7 @@ Win64 Package:
- mkdir build
- cd build
script:
- perl ../tools/make-version.pl --set-release
- python3 ../tools/make-version.py --set-release ..
- cmake -G "Visual Studio 17 2022" -A x64 -DUSE_qt6=ON -DENABLE_LTO=off ..
- msbuild /verbosity:minimal "/consoleloggerparameters:PerformanceSummary;NoSummary" /maxcpucount Wireshark.sln
- msbuild /verbosity:minimal /maxcpucount test-programs.vcxproj
@ -366,7 +366,7 @@ macOS Arm Package:
- wireshark-macos-arm-package
retry: 1
script:
- perl tools/make-version.pl --set-release
- python3 tools/make-version.py --set-release .
- mkdir build
- cd build
- printf "\e[0Ksection_start:%s:cmake_section[collapsed=true]\r\e[0KRunning CMake" "$( date +%s)"
@ -400,7 +400,7 @@ macOS Intel Package:
script:
- export CMAKE_PREFIX_PATH=/usr/local/Qt-5.15.3
- export PATH="$PATH:$HOME/bin"
- perl tools/make-version.pl --set-release
- python3 tools/make-version.py --set-release .
- mkdir build
- cd build
- printf "\e[0Ksection_start:%s:cmake_section[collapsed=true]\r\e[0KRunning CMake" "$( date +%s)"

View File

@ -38,7 +38,7 @@ endif()
project(${_project_name} C CXX)
# Updated by tools/make-version.pl
# Updated by tools/make-version.py
set(PROJECT_MAJOR_VERSION 3)
set(PROJECT_MINOR_VERSION 7)
set(PROJECT_PATCH_VERSION 2)
@ -1715,8 +1715,8 @@ if(VCSVERSION_OVERRIDE)
else()
add_custom_target(vcs_version
BYPRODUCTS vcs_version.h
COMMAND ${PERL_EXECUTABLE}
${CMAKE_SOURCE_DIR}/tools/make-version.pl
COMMAND ${PYTHON_EXECUTABLE}
${CMAKE_SOURCE_DIR}/tools/make-version.py
${CMAKE_SOURCE_DIR}
)
set_target_properties(vcs_version PROPERTIES FOLDER "Auxiliary")
@ -3582,8 +3582,8 @@ if(RPMBUILD_EXECUTABLE)
endif()
execute_process(
COMMAND ${PERL_EXECUTABLE}
${CMAKE_SOURCE_DIR}/tools/make-version.pl
COMMAND ${PYTHON_EXECUTABLE}
${CMAKE_SOURCE_DIR}/tools/make-version.py
${CMAKE_SOURCE_DIR}
)

View File

@ -38,7 +38,7 @@ build:
project: build\Wireshark.sln
before_build:
- perl tools/make-version.pl --set-release --untagged-version-extra=-{vcsinfo}-AppVeyor --tagged-version-extra=-AppVeyor
- python3 tools/make-version.py --set-release --untagged-version-extra=-{vcsinfo}-AppVeyor --tagged-version-extra=-AppVeyor
- mkdir build
- cd build
- cmake -E time cmake -DCMAKE_SYSTEM_VERSION=10.0.20348.0 -G "%CMAKE_GENERATOR%" ..

View File

@ -1,6 +1,6 @@
<!-- Document information for the Developer's Guide. -->
<!-- Updated by tools/make-version.pl -->
<!-- Updated by tools/make-version.py -->
<subtitle>For Wireshark 3.7</subtitle>
<!-- <title><inlinegraphic entityref="WiresharkLogo" valign="middle" format="PNG"/> &DocumentTitle;</title> -->

View File

@ -1,6 +1,6 @@
<!-- Document information for the User's Guide. -->
<!-- Updated by tools/make-version.pl -->
<!-- Updated by tools/make-version.py -->
<subtitle>For Wireshark 3.7</subtitle>
<!--

View File

@ -899,16 +899,16 @@ show how to restrict access using setcap and setuid respectively:
===== Customization
Custom version information can be added by running
`tools/make-version.pl`. If your package contains significant changes we
`tools/make-version.py`. If your package contains significant changes we
recommend that you use this to differentiate it from official Wireshark
releases.
[source, sh]
----
tools/make-version.pl --set-release --untagged-version-extra=-{vcsinfo}-FooCorp --tagged-version-extra=-FooCorp
tools/make-version.py --set-release --untagged-version-extra=-{vcsinfo}-FooCorp --tagged-version-extra=-FooCorp .
----
See `tools/make-version.pl` for details.
See `tools/make-version.py` for details.
The Git version corresponding to each release is in _version.h_. It's
defined as a string. If you need a numeric definition, let us know.

View File

@ -73,7 +73,7 @@ set(USBPCAP_PACKAGE_VERSION "1.5.4.0")
# To do:
# - Sync the various version names between CMake and NSIS.
# - Set CMakeLists.txt version strings in tools/make-version.pl
# - Set CMakeLists.txt version strings in tools/make-version.py
# - Add a VERSION_EXTRA cmake option
set (PRODUCT_VERSION ${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}.${PROJECT_BUILD_VERSION})
set (LOG_PRODUCT_VERSION ${LOG_PROJECT_MAJOR_VERSION}.${LOG_PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}.${PROJECT_BUILD_VERSION})

View File

@ -33,7 +33,7 @@ shift $(( OPTIND - 1 ))
# The remaining parameter, if set, is a package version such as 3.4.5
# or 3.4.5-67-gabcd4321
# By default the version from make-version.pl + CMake is used.
# By default the version from make-version.py + CMake is used.
PROJECT_VERSION=@PROJECT_VERSION@
if test -n "${1-}"; then
PROJECT_VERSION="$1"

View File

@ -71,7 +71,7 @@ endif()
# To do:
# - Sync the various version names between CMake and Wix.
# - Set CMakeLists.txt version strings in tools/make-version.pl
# - Set CMakeLists.txt version strings in tools/make-version.py
# - Add a VERSION_EXTRA cmake option
set (VERSION "${PROJECT_VERSION}")
set(PRODUCT_VERSION ${PROJECT_MAJOR_VERSION}.${PROJECT_MINOR_VERSION}.${PROJECT_PATCH_VERSION}.${PROJECT_BUILD_VERSION})

View File

@ -1,685 +0,0 @@
#!/usr/bin/perl -w
#
# Copyright 2004 Jörg Mayer (see AUTHORS file)
#
# Wireshark - Network traffic analyzer
# By Gerald Combs <gerald@wireshark.org>
# Copyright 1998 Gerald Combs
#
# SPDX-License-Identifier: GPL-2.0-or-later
# See below for usage.
#
# If run with the "-r" or "--set-release" argument the VERSION macro in
# CMakeLists.txt will have the version_extra template appended to the
# version number. vcs_version.h will _not_ be generated if either argument is
# present.
#
# make-version.pl is called during the build to update vcs_version.h in the build
# directory. To set a fixed version, use something like:
#
# cmake -DVCSVERSION_OVERRIDE="Git v3.1.0 packaged as 3.1.0-1"
#
# XXX - We're pretty dumb about the "{vcsinfo}" substitution, and about having
# spaces in the package format.
use strict;
use Time::Local;
use File::Basename;
use File::Spec;
use POSIX qw(strftime);
use Getopt::Long;
use Pod::Usage;
use IO::Handle;
use English;
my $version_major = undef;
my $version_minor = undef;
my $version_micro = undef;
my $tagged_version_extra = "";
my $untagged_version_extra = "-{vcsinfo}";
my $force_extra = undef;
my $package_string = "";
my $version_file = 'vcs_version.h';
my $vcs_name = "Git";
my $last_change = 0;
my $num_commits = 0;
my $commit_id = '';
my $git_description = undef;
my $get_vcs = 0;
my $set_vcs = 0;
my $print_vcs = 0;
my $set_version = undef;
my $set_release = 0;
my $is_tagged = 0;
my $git_client = 0;
my $svn_client = 0;
my $git_svn = 0;
my $script_dir = dirname(__FILE__);
my $src_dir = "$script_dir/..";
my $verbose = 0;
my $devnull = File::Spec->devnull();
my $enable_vcsversion = 1;
# Ensure we run with correct locale
$ENV{LANG} = "C";
$ENV{LC_ALL} = "C";
$ENV{GIT_PAGER} = "";
sub print_diag {
print STDERR @_ if $verbose;
}
# Attempt to get revision information from the repository.
sub read_repo_info {
return if ($set_version);
my $line;
my $release_candidate = "";
my $info_source = "Unknown";
my $is_git_repo = 0;
my $git_abbrev_length = 12;
my $git_cdir;
my $vcs_tag;
my $info_cmd = "";
# Tarball produced by 'git archive' will have the $Format string
# substituted due to the use of 'export-subst' in .gitattributes.
my $git_archive_commit = '$Format:%H$';
my @git_refs = split(/, /, '$Format:%D$');
if (substr($git_archive_commit, 0, 1) eq '$') {
# If $Format is still present, then this is not a git archive.
$git_archive_commit = undef;
} else {
foreach my $git_ref (@git_refs) {
if ($git_ref =~ /^tag: (v[1-9].+)/) {
$vcs_tag = $1;
$is_tagged = 1;
}
}
}
$package_string = $untagged_version_extra;
# For tarball releases, do not invoke git at all and instead rely on
# versioning information that was provided at tarball creation time.
if ($git_archive_commit) {
$info_source = "git archive";
} elsif (-e "$src_dir/.git" && ! -d "$src_dir/.git/svn") {
$info_source = "Command line (git)";
$git_client = 1;
$is_git_repo = 1;
} elsif (-d "$src_dir/.svn" or -d "$src_dir/../.svn") {
$info_source = "Command line (svn info)";
$info_cmd = "cd $src_dir; svn info";
$svn_client = 1;
} elsif (-d "$src_dir/.git/svn") {
$info_source = "Command line (git-svn)";
$info_cmd = "(cd $src_dir; git svn info)";
$is_git_repo = 1;
$git_svn = 1;
}
# Make sure git is available.
if ($is_git_repo && !`git --version`) {
print STDERR "Git unavailable. Git revision will be missing from version string.\n";
return;
}
# Check whether to include VCS version information in vcs_version.h
if ($is_git_repo) {
chomp($git_cdir = qx{git --git-dir="$src_dir/.git" rev-parse --git-common-dir 2> $devnull});
if ($git_cdir && -f "$git_cdir/wireshark-disable-versioning") {
print_diag "Header versioning disabled using git override.\n";
$enable_vcsversion = 0;
}
}
#Git can give us:
#
# A big ugly hash: git rev-parse HEAD
# efd7cb38e67cbfd3333a8c2fd4bc47aaec4ba83c
#
# A small ugly hash: git rev-parse --short HEAD
# efd7cb38e6
#
# The upstream branch path: git rev-parse --abbrev-ref --symbolic-full-name @{upstream}
# origin/master
#
# A version description: git describe --tags --dirty
# v3.3.0rc0-1829-gefd7cb38e6
#
# Number of commits in this branch: git rev-list --count HEAD
# 78451
#
# Number of commits since v3.3.0rc0: git rev-list --count beb1fee6586725bd37651b8a73a1ef51888e99be..HEAD
# 1829
# Where git show-ref --tags -d | grep v3.3.0 | grep '{}'
# beb1fee6586725bd37651b8a73a1ef51888e99be refs/tags/v3.3.0rc0^{}
#
# Refs: git ls-remote https://gitlab.com/wireshark/wireshark.git | head -n1
# efd7cb38e67cbfd3333a8c2fd4bc47aaec4ba83c HEAD
if ($git_archive_commit) {
# Assume a full commit hash, abbreviate it.
$commit_id = substr($git_archive_commit, 0, $git_abbrev_length);
} elsif ($git_client) {
eval {
use warnings "all";
no warnings "all";
chomp($line = qx{git --git-dir="$src_dir"/.git log -1 --pretty=format:%at});
if ($? == 0 && length($line) > 1) {
$last_change = $line;
}
# Commits since last annotated tag.
chomp($line = qx{git --git-dir="$src_dir"/.git describe --abbrev=$git_abbrev_length --long --always --match "v[1-9]*"});
if ($? == 0 && length($line) > 1) {
my @parts = split(/-/, $line);
$git_description = $line;
$num_commits = $parts[-2] ? $parts[-2] : "0";
$commit_id = $parts[-1];
if ($line =~ /v\d+\.\d+\.\d+(rc\d+)-/) {
$release_candidate = $1;
}
chomp($vcs_tag = qx{git --git-dir="$src_dir"/.git describe --exact-match --match "v[1-9]*" 2> $devnull});
$is_tagged = ! ($? >> 8);
}
1;
};
} elsif ($svn_client || $git_svn) {
eval {
use warnings "all";
no warnings "all";
$line = qx{$info_cmd};
if (defined($line)) {
if ($line =~ /Last Changed Date: (\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)/) {
$last_change = timegm($6, $5, $4, $3, $2 - 1, $1);
}
if ($line =~ /Last Changed Rev: (\d+)/) {
$num_commits = $1;
}
$vcs_name = "SVN";
}
1;
};
}
if (defined $num_commits and $num_commits == 0 and -e "$src_dir/.git") {
# Try git...
eval {
use warnings "all";
no warnings "all";
# If someone had properly tagged 1.9.0 we could also use
# "git describe --abbrev=1 --tags HEAD"
$info_cmd = "(cd $src_dir; git log --format='%b' -n 1)";
$line = qx{$info_cmd};
if (defined($line)) {
if ($line =~ /svn path=.*; revision=(\d+)/) {
$num_commits = $1;
}
}
$info_cmd = "(cd $src_dir; git log --format='%ad' -n 1 --date=iso)";
$line = qx{$info_cmd};
if (defined($line)) {
if ($line =~ /(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)/) {
$last_change = timegm($6, $5, $4, $3, $2 - 1, $1);
}
}
1;
};
}
if ($force_extra) {
if ($force_extra eq "tagged") {
$is_tagged = 1;
} elsif ($force_extra eq "untagged") {
$is_tagged = 0;
}
}
if ($is_tagged) {
print "We are on tag $vcs_tag.\n";
$package_string = $tagged_version_extra;
} else {
print "We are not tagged.\n";
}
# If we picked up the revision and modification time,
# generate our strings.
if ($package_string) {
if(defined $num_commits){
if($commit_id){
$package_string =~ s/{vcsinfo}/$num_commits-$commit_id/;
}else{
$package_string =~ s/{vcsinfo}/$num_commits/;
}
}
else{
if($commit_id){
$package_string =~ s/{vcsinfo}/-$commit_id/;
}else{
$package_string =~ s/{vcsinfo}//;
}
}
}
$package_string = $release_candidate . $package_string;
if ($get_vcs) {
print <<"Fin";
Commit distance : $num_commits
Commit ID : $commit_id
Revision source : $info_source
Release stamp : $package_string
Fin
} elsif ($print_vcs) {
print new_version_h();
}
}
# Read CMakeLists.txt, then write it back out with updated "set(PROJECT_..._VERSION ...)
# lines
# set(PROJECT_MAJOR_VERSION 1)
# set(PROJECT_MINOR_VERSION 99)
# set(PROJECT_PATCH_VERSION 0)
# set(PROJECT_BUILD_VERSION 999)
# set(PROJECT_VERSION_EXTENSION "-rc5")
sub update_cmakelists_txt
{
my $line;
my $contents = "";
my $version = "";
my $filepath = "$src_dir/CMakeLists.txt";
return if (!$set_version && $package_string eq "");
open(CFGIN, "< $filepath") || die "Can't read $filepath!";
while ($line = <CFGIN>) {
if ($line =~ /^set *\( *PROJECT_MAJOR_VERSION .*?([\r\n]+)$/) {
$line = sprintf("set(PROJECT_MAJOR_VERSION %d)$1", $version_major);
} elsif ($line =~ /^set *\( *PROJECT_MINOR_VERSION .*?([\r\n]+)$/) {
$line = sprintf("set(PROJECT_MINOR_VERSION %d)$1", $version_minor);
} elsif ($line =~ /^set *\( *PROJECT_PATCH_VERSION .*?([\r\n]+)$/) {
$line = sprintf("set(PROJECT_PATCH_VERSION %d)$1", $version_micro);
} elsif ($line =~ /^set *\( *PROJECT_BUILD_VERSION .*?([\r\n]+)$/) {
$line = sprintf("set(PROJECT_BUILD_VERSION %d)$1", $num_commits);
} elsif ($line =~ /^set *\( *PROJECT_VERSION_EXTENSION .*?([\r\n]+)$/) {
$line = sprintf("set(PROJECT_VERSION_EXTENSION \"%s\")$1", $package_string);
}
$contents .= $line
}
open(CFGIN, "> $filepath") || die "Can't write $filepath!";
print(CFGIN $contents);
close(CFGIN);
print "$filepath has been updated.\n";
}
# Read docbook/attributes.adoc, then write it back out with an updated
# wireshark-version replacement line.
sub update_attributes_asciidoc
{
my $line;
my $contents = "";
my $version = "";
my $filepath = "$src_dir/docbook/attributes.adoc";
open(ADOC_CONF, "< $filepath") || die "Can't read $filepath!";
while ($line = <ADOC_CONF>) {
# :wireshark-version: 2.3.1
if ($line =~ /^:wireshark-version:.*?([\r\n]+)$/) {
$line = sprintf(":wireshark-version: %d.%d.%d$1",
$version_major,
$version_minor,
$version_micro,
);
}
$contents .= $line
}
open(ADOC_CONF, "> $filepath") || die "Can't write $filepath!";
print(ADOC_CONF $contents);
close(ADOC_CONF);
print "$filepath has been updated.\n";
}
sub update_docinfo_asciidoc
{
my $line;
my @paths = ("$src_dir/docbook/developer-guide-docinfo.xml",
"$src_dir/docbook/user-guide-docinfo.xml");
foreach my $filepath (@paths) {
my $contents = "";
open(DOCINFO_XML, "< $filepath") || die "Can't read $filepath!";
while ($line = <DOCINFO_XML>) {
if ($line =~ /^<subtitle>For Wireshark \d.\d+<\/subtitle>([\r\n]+)$/) {
$line = sprintf("<subtitle>For Wireshark %d.%d</subtitle>$1",
$version_major,
$version_minor,
);
}
$contents .= $line
}
open(DOCINFO_XML, "> $filepath") || die "Can't write $filepath!";
print(DOCINFO_XML $contents);
close(DOCINFO_XML);
print "$filepath has been updated.\n";
}
}
# Read packaging/debian/changelog, then write back out an updated version.
sub update_debian_changelog
{
my $line;
my $contents = "";
my $version = "";
my $filepath = "$src_dir/packaging/debian/changelog";
open(CHANGELOG, "< $filepath") || die "Can't read $filepath!";
while ($line = <CHANGELOG>) {
if (CHANGELOG->input_line_number() == 1) {
$line =~ /^.*?([\r\n]+)$/;
$line = sprintf("wireshark (%d.%d.%d%s) unstable; urgency=low$1",
$version_major,
$version_minor,
$version_micro,
$package_string,
);
}
$contents .= $line
}
open(CHANGELOG, "> $filepath") || die "Can't write $filepath!";
print(CHANGELOG $contents);
close(CHANGELOG);
print "$filepath has been updated.\n";
}
# Read CMakeLists.txt for each library, then write back out an updated version.
sub update_cmake_lib_releases
{
my $line;
my $contents = "";
my $version = "";
my $filedir;
my $filepath;
for $filedir ("$src_dir/epan", "$src_dir/wiretap") { # "$src_dir/wsutil"
$contents = "";
$filepath = $filedir . "/CMakeLists.txt";
open(CMAKELISTS_TXT, "< $filepath") || die "Can't read $filepath!";
while ($line = <CMAKELISTS_TXT>) {
# VERSION "0.0.0" SOVERSION 0
if ($line =~ /^(\s*VERSION\s+"\d+\.\d+\.)\d+(".*[\r\n]+)$/) {
$line = sprintf("$1%d$2", $version_micro);
}
$contents .= $line
}
open(CMAKELISTS_TXT, "> $filepath") || die "Can't write $filepath!";
print(CMAKELISTS_TXT $contents);
close(CMAKELISTS_TXT);
print "$filepath has been updated.\n";
}
}
# Update distributed files that contain any version information
sub update_versioned_files
{
# Matches CMakeLists.txt
printf "GR: %d, MaV: %d, MiV: %d, PL: %d, EV: %s\n",
$num_commits, $version_major,
$version_minor, $version_micro,
$package_string;
&update_cmakelists_txt;
&update_debian_changelog;
if ($set_version) {
&update_attributes_asciidoc;
&update_docinfo_asciidoc;
&update_cmake_lib_releases;
}
}
sub new_version_h
{
my $line;
if (!$enable_vcsversion) {
return "/* #undef VCSVERSION */\n";
}
if ($git_description) {
# Do not bother adding the git branch, the git describe output
# normally contains the base tag and commit ID which is more
# than sufficient to determine the actual source tree.
return "#define VCSVERSION \"$git_description\"\n";
}
if ($last_change && $num_commits) {
$line = sprintf("v%d.%d.%d",
$version_major,
$version_minor,
$version_micro,
);
return "#define VCSVERSION \"$line-$vcs_name-$num_commits\"\n";
}
if ($commit_id) {
return "#define VCSVERSION \"$vcs_name commit $commit_id\"\n";
}
return "#define VCSVERSION \"$vcs_name Rev Unknown from unknown\"\n";
}
# Print the version control system's version to $version_file.
# Don't change the file if it is not needed.
#
# XXX - We might want to add VCSVERSION to CMakeLists.txt so that it can
# generate vcs_version.h independently.
sub print_VCS_REVISION
{
my $VCS_REVISION;
my $needs_update = 1;
$VCS_REVISION = new_version_h();
if (open(OLDREV, "<$version_file")) {
my $old_VCS_REVISION = <OLDREV>;
if ($old_VCS_REVISION eq $VCS_REVISION) {
$needs_update = 0;
}
close OLDREV;
}
if (! $set_vcs) { return; }
if ($needs_update) {
# print "Updating $version_file so it contains:\n$VCS_REVISION";
open(VER, ">$version_file") || die ("Cannot write to $version_file ($!)\n");
print VER "$VCS_REVISION";
close VER;
print "$version_file has been updated.\n";
} elsif (!$enable_vcsversion) {
print "$version_file disabled.\n";
} else {
print "$version_file unchanged.\n";
}
}
# Read our major, minor, and micro version from CMakeLists.txt.
sub get_version
{
my $line;
my $filepath = "$src_dir/CMakeLists.txt";
open(CFGIN, "< $filepath") || die "Can't read $filepath!";
while ($line = <CFGIN>) {
$line =~ s/^\s+|\s+$//g;
if ($line =~ /^set *\( *PROJECT_MAJOR_VERSION *(\d+) *\)$/) {
$version_major = $1;
} elsif ($line =~ /^set *\( *PROJECT_MINOR_VERSION *(\d+) *\)$/) {
$version_minor = $1;
} elsif ($line =~ /^set *\( *PROJECT_PATCH_VERSION *(\d+) *\)$/) {
$version_micro = $1;
}
}
close(CFGIN);
die "Couldn't get major version" if (!defined($version_major));
die "Couldn't get minor version" if (!defined($version_minor));
die "Couldn't get micro version" if (!defined($version_micro));
}
# Read values from the configuration file, if it exists.
sub get_config {
my $arg;
my $show_help = 0;
# Get our command-line args
# XXX - Do we need an option to undo --set-release?
GetOptions(
"help|h", \$show_help,
"tagged-version-extra|t=s", \$tagged_version_extra,
"untagged-version-extra|u=s", \$untagged_version_extra,
"force-extra|f=s", \$force_extra,
"get-vcs|g", \$get_vcs,
"set-vcs|s", \$set_vcs,
"print-vcs", \$print_vcs,
"set-version|v=s", \$set_version,
"set-release|r", \$set_release,
"verbose", \$verbose
) || pod2usage(2);
if ($show_help) { pod2usage(1); }
if ( !( $show_help || $get_vcs || $set_vcs || $print_vcs || $set_version || $set_release ) ) {
$set_vcs = 1;
}
if ($force_extra && !($force_extra eq "tagged" || $force_extra eq "untagged")) {
die "force-extra must be one of \"tagged\" or \"untagged\".\n";
}
if ($set_version) {
if ($set_version =~ /^(\d+)\.(\d+)\.(\d+)/) {
$version_major = $1;
$version_minor = $2;
$version_micro = $3;
} else {
die "\"$set_version\" isn't a version.\n";
}
}
if ($#ARGV >= 0) {
$src_dir = $ARGV[0]
}
return 1;
}
##
## Start of code
##
&get_version();
&get_config();
if (! $set_version) {
&read_repo_info();
}
&print_VCS_REVISION;
if ($set_version || $set_release) {
if ($set_version) {
print "Generating version information.\n";
}
&update_versioned_files;
}
__END__
=head1 NAM
make-version.pl - Get and set build-time version information for Wireshark
=head1 SYNOPSIS
make-version.pl [options] [source directory]
=head1 OPTIONS
=over 4
=item --help, -h
Show this help message.
=item --tagged-version-extra=<format>, -t <format>
Extra version information format to use when a tag is found. No format
(an empty string) is used by default.
=item --untagged-version-extra, -u <format>
Extra version information format to use when no tag is found. The format
"-{vcsinfo}" (the number of commits and commit ID) is used by default.
=item --force-extra=<tagged,untagged>, -f <tagged,untagged>
Force either the tagged or untagged format to be used.
=item --get-vcs, -g
Print the VCS revision and source.
=item --print-vcs
Print the vcs version to standard output
=item --set-version=<x.y.z>, -v <x.y.z>
Set the major, minor, and micro versions in the top-level
CMakeLists.txt, configure.ac, docbook/attributes.adoc,
packaging/debian/changelog, and the CMakeLists.txt for all libraries
to the provided version number.
=item --set-release, -r
Set the extra release information in the top-level CMakeLists.txt
based on either default or command-line specified options.
=item --verbose
Print diagnostic messages to STDERR.
=back
=cut
#
# Editor modelines - https://www.wireshark.org/tools/modelines.html
#
# Local variables:
# c-basic-offset: 8
# tab-width: 8
# indent-tabs-mode: t
# End:
#
# vi: set shiftwidth=8 tabstop=8 noexpandtab:
# :indentSize=8:tabSize=8:noTabs=false:
#
#

445
tools/make-version.py Executable file
View File

@ -0,0 +1,445 @@
#!/usr/bin/env python3
#
# Copyright 2022 by Moshe Kaplan
# Based on make-version.pl by Jörg Mayer
#
# Wireshark - Network traffic analyzer
# By Gerald Combs <gerald@wireshark.org>
# Copyright 1998 Gerald Combs
#
# SPDX-License-Identifier: GPL-2.0-or-later
# See below for usage.
#
# If run with the "-r" or "--set-release" argument the VERSION macro in
# CMakeLists.txt will have the version_extra template appended to the
# version number. vcs_version.h will _not_ be generated if either argument is
# present.
#
# make-version.py is called during the build to update vcs_version.h in the build
# directory. To set a fixed version, use something like:
#
# cmake -DVCSVERSION_OVERRIDE="Git v3.1.0 packaged as 3.1.0-1"
#
# XXX - We're pretty dumb about the "{vcsinfo}" substitution, and about having
# spaces in the package format.
import argparse
import os
import os.path
import re
import shlex
import shutil
import sys
import subprocess
GIT_ABBREV_LENGTH = 12
# `git archive` will use an 'export-subst' entry in .gitattributes to replace
# the $Format strings with `git log --pretty=format:` placeholders.
# The output will look something like the following:
# GIT_EXPORT_SUBST_H = '51315cf37cdf6c0add1b1c99cb7941aac4489a6f'
# GIT_EXPORT_SUBST_D = 'HEAD -> master, upstream/master, upstream/HEAD'
# If the text "$Format" is still present, it means that
# git archive did not replace the $Format string, which
# means that this not a git archive.
GIT_EXPORT_SUBST_H = '$Format:%H$'
GIT_EXPORT_SUBST_D = '$Format:%D$'
IS_GIT_ARCHIVE = not GIT_EXPORT_SUBST_H.startswith('$Format')
def update_cmakelists_txt(src_dir, set_version, repo_data):
if not set_version and repo_data['package_string'] == "":
return
cmake_filepath = os.path.join(src_dir, "CMakeLists.txt")
with open(cmake_filepath, encoding='utf-8') as fh:
cmake_contents = fh.read()
MAJOR_PATTERN = r"^set *\( *PROJECT_MAJOR_VERSION *\d+ *\)$"
MINOR_PATTERN = r"^set *\( *PROJECT_MINOR_VERSION *\d+ *\)$"
PATCH_PATTERN = r"^set *\( *PROJECT_PATCH_VERSION *\d+ *\)$"
VERSION_EXTENSION_PATTERN = r"^set *\( *PROJECT_VERSION_EXTENSION .*?$"
new_cmake_contents = cmake_contents
new_cmake_contents = re.sub(MAJOR_PATTERN,
f"set(PROJECT_MAJOR_VERSION {repo_data['version_major']})",
new_cmake_contents,
flags=re.MULTILINE)
new_cmake_contents = re.sub(MINOR_PATTERN,
f"set(PROJECT_MINOR_VERSION {repo_data['version_minor']})",
new_cmake_contents,
flags=re.MULTILINE)
new_cmake_contents = re.sub(PATCH_PATTERN,
f"set(PROJECT_PATCH_VERSION {repo_data['version_patch']})",
new_cmake_contents,
flags=re.MULTILINE)
new_cmake_contents = re.sub(VERSION_EXTENSION_PATTERN,
f"set(PROJECT_VERSION_EXTENSION \"{repo_data['package_string']}\")",
new_cmake_contents,
flags=re.MULTILINE)
with open(cmake_filepath, mode='w', encoding='utf-8') as fh:
fh.write(new_cmake_contents)
print(cmake_filepath + " has been updated.")
def update_debian_changelog(src_dir, repo_data):
# Read packaging/debian/changelog, then write back out an updated version.
deb_changelog_filepath = os.path.join(src_dir, "packaging", "debian", "changelog")
with open(deb_changelog_filepath, encoding='utf-8') as fh:
changelog_contents = fh.read()
CHANGELOG_PATTERN = r"^.*"
text_replacement = f"wireshark ({repo_data['version_major']}.{repo_data['version_minor']}.{repo_data['version_patch']}{repo_data['package_string']}) unstable; urgency=low"
# Note: Only need to replace the first line, so we don't use re.MULTILINE or re.DOTALL
new_changelog_contents = re.sub(CHANGELOG_PATTERN, text_replacement, changelog_contents)
with open(deb_changelog_filepath, mode='w', encoding='utf-8') as fh:
fh.write(new_changelog_contents)
print(deb_changelog_filepath + " has been updated.")
def update_attributes_asciidoc(src_dir, repo_data):
# Read docbook/attributes.adoc, then write it back out with an updated
# wireshark-version replacement line.
asiidoc_filepath = os.path.join(src_dir, "docbook", "attributes.adoc")
with open(asiidoc_filepath, encoding='utf-8') as fh:
asciidoc_contents = fh.read()
# Sample line (without quotes): ":wireshark-version: 2.3.1"
ASCIIDOC_PATTERN = r"^:wireshark-version:.*$"
text_replacement = f":wireshark-version: {repo_data['version_major']}.{repo_data['version_minor']}.{repo_data['version_patch']}"
new_asciidoc_contents = re.sub(ASCIIDOC_PATTERN, text_replacement, asciidoc_contents, flags=re.MULTILINE)
with open(asiidoc_filepath, mode='w', encoding='utf-8') as fh:
fh.write(new_asciidoc_contents)
print(asiidoc_filepath + " has been updated.")
def update_docinfo_asciidoc(src_dir, repo_data):
doc_paths = []
doc_paths += [os.path.join(src_dir, 'docbook', 'developer-guide-docinfo.xml')]
doc_paths += [os.path.join(src_dir, 'docbook', 'user-guide-docinfo.xml')]
for doc_path in doc_paths:
with open(doc_path, encoding='utf-8') as fh:
doc_contents = fh.read()
# Sample line (without quotes): "<subtitle>For Wireshark 1.2</subtitle>"
DOC_PATTERN = r"^<subtitle>For Wireshark \d+.\d+<\/subtitle>$"
text_replacement = f"<subtitle>For Wireshark {repo_data['version_major']}.{repo_data['version_minor']}</subtitle>"
new_doc_contents = re.sub(DOC_PATTERN, text_replacement, doc_contents, flags=re.MULTILINE)
with open(doc_path, mode='w', encoding='utf-8') as fh:
fh.write(new_doc_contents)
print(doc_path + " has been updated.")
def update_cmake_lib_releases(src_dir, repo_data):
# Read CMakeLists.txt for each library, then write back out an updated version.
dir_paths = []
dir_paths += [os.path.join(src_dir, 'epan')]
dir_paths += [os.path.join(src_dir, 'wiretap')]
for dir_path in dir_paths:
cmakelists_filepath = os.path.join(dir_path, "CMakeLists.txt")
with open(cmakelists_filepath, encoding='utf-8') as fh:
cmakelists_contents = fh.read()
# Sample line (without quotes; note leading tab: " VERSION "0.0.0" SOVERSION 0")
VERSION_PATTERN = r'^(\s*VERSION\s+"\d+\.\d+\.)\d+'
replacement_text = f"\\g<1>{repo_data['version_patch']}"
new_cmakelists_contents = re.sub(VERSION_PATTERN,
replacement_text,
cmakelists_contents,
flags=re.MULTILINE)
with open(cmakelists_filepath, mode='w', encoding='utf-8') as fh:
fh.write(new_cmakelists_contents)
print(cmakelists_filepath + " has been updated.")
# Update distributed files that contain any version information
def update_versioned_files(src_dir, set_version, repo_data):
update_cmakelists_txt(src_dir, set_version, repo_data)
update_debian_changelog(src_dir, repo_data)
if set_version:
update_attributes_asciidoc(src_dir, repo_data)
update_docinfo_asciidoc(src_dir, repo_data)
update_cmake_lib_releases(src_dir, repo_data)
def generate_version_h(repo_data):
# Generate new contents of version.h from repository data
if not repo_data.get('enable_vcsversion'):
return "/* #undef VCSVERSION */\n"
if repo_data.get('git_description'):
# Do not bother adding the git branch, the git describe output
# normally contains the base tag and commit ID which is more
# than sufficient to determine the actual source tree.
return f'#define VCSVERSION "{repo_data["git_description"]}"\n'
if repo_data.get('last_change') and repo_data.get('num_commits'):
version_string = f"v{repo_data['version_major']}.{repo_data['version_minor']}.{repo_data['version_patch']}"
vcs_line = f'#define VCSVERSION "{version_string}-Git-{repo_data["num_commits"]}"\n'
return vcs_line
if repo_data.get('commit_id'):
vcs_line = f'#define VCSVERSION "Git commit {repo_data["commit_id"]}"\n'
return vcs_line
vcs_line = '#define VCSVERSION "Git Rev Unknown from unknown"\n'
return vcs_line
def print_VCS_REVISION(version_file, repo_data, set_vcs):
# Write the version control system's version to $version_file.
# Don't change the file if it is not needed.
#
# XXX - We might want to add VCSVERSION to CMakeLists.txt so that it can
# generate vcs_version.h independently.
new_version_h = generate_version_h(repo_data)
needs_update = True
if os.path.exists(version_file):
with open(version_file, encoding='utf-8') as fh:
current_version_h = fh.read()
if current_version_h == new_version_h:
needs_update = False
if not set_vcs:
return
if needs_update:
with open(version_file, mode='w', encoding='utf-8') as fh:
fh.write(new_version_h)
print(version_file + " has been updated.")
elif not repo_data['enable_vcsversion']:
print(version_file + " disabled.")
else:
print(version_file + " unchanged.")
return
def get_version(cmakelists_file_data):
# Reads major, minor, and patch
# Sample data:
# set(PROJECT_MAJOR_VERSION 3)
# set(PROJECT_MINOR_VERSION 7)
# set(PROJECT_PATCH_VERSION 2)
MAJOR_PATTERN = r"^set *\( *PROJECT_MAJOR_VERSION *(\d+) *\)$"
MINOR_PATTERN = r"^set *\( *PROJECT_MINOR_VERSION *(\d+) *\)$"
PATCH_PATTERN = r"^set *\( *PROJECT_PATCH_VERSION *(\d+) *\)$"
major_match = re.search(MAJOR_PATTERN, cmakelists_file_data, re.MULTILINE)
minor_match = re.search(MINOR_PATTERN, cmakelists_file_data, re.MULTILINE)
patch_match = re.search(PATCH_PATTERN, cmakelists_file_data, re.MULTILINE)
if not major_match:
raise Exception("Couldn't get major version")
if not minor_match:
raise Exception("Couldn't get minor version")
if not patch_match:
raise Exception("Couldn't get patch version")
major_version = major_match.groups()[0]
minor_version = minor_match.groups()[0]
patch_version = patch_match.groups()[0]
return major_version, minor_version, patch_version
def read_git_archive(tagged_version_extra, untagged_version_extra):
# Reads key data from the git repo.
# For git archives, this does not need to access the source directory because
# `git archive` will use an 'export-subst' entry in .gitattributes to replace
# the value for GIT_EXPORT_SUBST_H in the script.
# Returns a dictionary with key values from the repository
is_tagged = False
for git_ref in GIT_EXPORT_SUBST_D.split(r', '):
match = re.match(r'^tag: (v[1-9].+)', git_ref)
if match:
is_tagged = True
vcs_tag = match.groups[0]
if is_tagged:
print(f"We are on tag {vcs_tag}.")
package_string = tagged_version_extra
else:
print("We are not tagged.")
package_string = untagged_version_extra
# Always 0 commits for a git archive
num_commits = 0
# Assume a full commit hash, abbreviate it.
commit_id = GIT_EXPORT_SUBST_H[:GIT_ABBREV_LENGTH]
package_string = package_string.replace("{vcsinfo}", str(num_commits) + "-" + commit_id)
repo_data = {}
repo_data['commit_id'] = commit_id
repo_data['enable_vcsversion'] = True
repo_data['info_source'] = "git archive"
repo_data['is_tagged'] = is_tagged
repo_data['num_commits'] = num_commits
repo_data['package_string'] = package_string
return repo_data
def read_git_repo(src_dir, tagged_version_extra, untagged_version_extra):
# Reads metadata from the git repo for generating the version string
# Returns the data in a dict
IS_GIT_INSTALLED = shutil.which('git') != ''
if not IS_GIT_INSTALLED:
print("Git unavailable. Git revision will be missing from version string.", file=sys.stderr)
return {}
GIT_DIR = os.path.join(src_dir, '.git')
# Check whether to include VCS version information in vcs_version.h
enable_vcsversion = True
git_get_commondir_cmd = shlex.split(f'git --git-dir="{GIT_DIR}" rev-parse --git-common-dir')
git_commondir = subprocess.check_output(git_get_commondir_cmd, universal_newlines=True).strip()
if git_commondir and os.path.exists(f"{git_commondir}{os.sep}wireshark-disable-versioning"):
print("Header versioning disabled using git override.")
enable_vcsversion = False
git_last_changetime_cmd = shlex.split(f'git --git-dir="{GIT_DIR}" log -1 --pretty=format:%at')
git_last_changetime = subprocess.check_output(git_last_changetime_cmd, universal_newlines=True).strip()
# Commits since last annotated tag.
# Output could be something like: v3.7.2rc0-64-g84d83a8292cb
# Or g84d83a8292cb
git_last_annotated_cmd = shlex.split(f'git --git-dir="{GIT_DIR}" describe --abbrev={GIT_ABBREV_LENGTH} --long --always --match "v[1-9]*"')
git_last_annotated = subprocess.check_output(git_last_annotated_cmd, universal_newlines=True).strip()
parts = git_last_annotated.split('-')
git_description = git_last_annotated
if len(parts) > 1:
num_commits = int(parts[1])
else:
num_commits = 0
commit_id = parts[-1]
release_candidate = ''
RC_PATTERN = r'^v\d+\.\d+\.\d+(rc\d+)$'
match = re.match(RC_PATTERN, parts[0])
if match:
release_candidate = match.groups()[0]
# This command is expected to fail if the version is not tagged
try:
git_vcs_tag_cmd = shlex.split(f'git --git-dir="{GIT_DIR}" describe --exact-match --match "v[1-9]*"')
git_vcs_tag = subprocess.check_output(git_vcs_tag_cmd, stderr=subprocess.DEVNULL, universal_newlines=True).strip()
is_tagged = True
except subprocess.CalledProcessError:
is_tagged = False
git_timestamp = ""
if num_commits == 0:
# Get the timestamp; format is similar to: 2022-06-27 23:09:20 -0400
# Note: This doesn't appear to be used, only checked for command success
git_timestamp_cmd = shlex.split(f'git --git-dir="{GIT_DIR}" log --format="%ad" -n 1 --date=iso')
git_timestamp = subprocess.check_output(git_timestamp_cmd, universal_newlines=True).strip()
if is_tagged:
print(f"We are on tag {git_vcs_tag}.")
package_string = tagged_version_extra
else:
print("We are not tagged.")
package_string = untagged_version_extra
package_string = release_candidate + package_string.replace("{vcsinfo}", str(num_commits) + "-" + commit_id)
repo_data = {}
repo_data['commit_id'] = commit_id
repo_data['enable_vcsversion'] = enable_vcsversion
repo_data['git_timestamp'] = git_timestamp
repo_data['git_description'] = git_description
repo_data['info_source'] = "Command line (git)"
repo_data['is_tagged'] = is_tagged
repo_data['last_change'] = git_last_changetime
repo_data['num_commits'] = num_commits
repo_data['package_string'] = package_string
return repo_data
def parse_versionstring(version_arg):
version_parts = version_arg.split('.')
if len(version_parts) != 3:
msg = "Version must have three numbers of the form x.y.z. You entered: " + version_arg
raise argparse.ArgumentTypeError(msg)
for i, version_type in enumerate(('Major', 'Minor', 'Patch')):
try:
int(version_parts[i])
except ValueError:
msg = f"{version_type} version must be a number! {version_type} version was '{version_parts[i]}'"
raise argparse.ArgumentTypeError(msg)
return version_parts
def read_repo_info(src_dir, tagged_version_extra, untagged_version_extra):
if IS_GIT_ARCHIVE:
repo_data = read_git_archive(tagged_version_extra, untagged_version_extra)
elif os.path.exists(src_dir + os.sep + '.git') and not os.path.exists(os.path.join(src_dir, '.git', 'svn')):
repo_data = read_git_repo(src_dir, tagged_version_extra, untagged_version_extra)
else:
raise Exception(src_dir + " does not appear to be a git repo or git archive!")
cmake_path = os.path.join(src_dir, "CMakeLists.txt")
with open(cmake_path, encoding='utf-8') as fh:
version_major, version_minor, version_patch = get_version(fh.read())
repo_data['version_major'] = version_major
repo_data['version_minor'] = version_minor
repo_data['version_patch'] = version_patch
return repo_data
# CMakeLists.txt calls this with no arguments to create vcs_version.h
# AppVeyor calls this with --set-release --untagged-version-extra=-{vcsinfo}-AppVeyor --tagged-version-extra=-AppVeyor
# .gitlab-ci calls this with --set-release
# Release checklist requires --set-version
def main():
parser = argparse.ArgumentParser(description='Wireshark file and package versions')
action_group = parser.add_mutually_exclusive_group()
action_group.add_argument('--set-version', '-v', metavar='<x.y.z>', type=parse_versionstring, help='Set the major, minor, and patch versions in the top-level CMakeLists.txt, docbook/attributes.adoc, packaging/debian/changelog, and the CMakeLists.txt for all libraries to the provided version number')
sr = action_group.add_argument('--set-release', '-r', action='store_true', help='Set the extra release information in the top-level CMakeLists.txt based on either default or command-line specified options.')
setrel_group = parser.add_argument_group()
setrel_group._group_actions.append(sr)
setrel_group.add_argument('--tagged-version-extra', '-t', default="", help="Extra version information format to use when a tag is found. No format \
(an empty string) is used by default.")
setrel_group.add_argument('--untagged-version-extra', '-u', default='-{vcsinfo}', help='Extra version information format to use when no tag is found. The format "-{vcsinfo}" (the number of commits and commit ID) is used by default.')
parser.add_argument("src_dir", metavar='src_dir', nargs=1, help="path to source code")
args = parser.parse_args()
src_dir = args.src_dir[0]
if args.set_version:
repo_data = {}
repo_data['version_major'] = args.set_version[0]
repo_data['version_minor'] = args.set_version[1]
repo_data['version_patch'] = args.set_version[2]
repo_data['package_string'] = ''
else:
repo_data = read_repo_info(src_dir, args.tagged_version_extra, args.untagged_version_extra)
set_vcs = not (args.set_release or args.set_version)
VERSION_FILE = 'vcs_version.h'
print_VCS_REVISION(VERSION_FILE, repo_data, set_vcs)
if args.set_release or args.set_version:
update_versioned_files(src_dir, args.set_version, repo_data)
if __name__ == "__main__":
main()