bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cef/tools/cef_version.py

276 lines
9.9 KiB
Python
Raw Blame History

# Copyright (c) 2019 The Chromium Embedded Framework Authors. All rights
# reserved. Use of this source code is governed by a BSD-style license that
# can be found in the LICENSE file.
from __future__ import absolute_import
from __future__ import print_function
from file_util import *
import git_util as git
import os
class VersionFormatter:
""" Formats CEF version information. """
def __init__(self, chromium_src_path=None):
if chromium_src_path is None:
# Relative to the current directory.
script_path = os.path.abspath(os.path.dirname(__file__))
chromium_src_path = os.path.abspath(
os.path.join(script_path, os.pardir, os.pardir))
self.src_path = chromium_src_path
assert os.path.isdir(self.src_path), self.src_path
self.cef_path = os.path.join(self.src_path, 'cef')
assert os.path.isdir(self.cef_path), self.cef_path
# Whether to use the old version format by default.
self._old_format_default = \
bool(int(os.environ.get('CEF_OLD_VERSION_FORMAT', '0')))
self.reset()
def reset(self):
""" Reset internal state. """
self._chrome_version = {}
self._cef_version = {}
self._cef_commit = {}
self._branch_version = {}
self._old_version_string = None
self._old_version_parts = {}
self._version_string = None
self._version_parts = {}
def get_chrome_version_components(self):
""" Returns Chrome version components. """
if not bool(self._chrome_version):
file_path = os.path.join(self.src_path, 'chrome', 'VERSION')
assert os.path.isfile(file_path), file_path
read_version_file(file_path, self._chrome_version)
return self._chrome_version
def get_cef_version_components(self):
""" Returns CEF version components. """
if not bool(self._cef_version):
file_path = os.path.join(self.cef_path, 'VERSION.in')
assert os.path.isfile(file_path), file_path
read_version_file(file_path, self._cef_version)
return self._cef_version
def get_cef_commit_components(self):
""" Returns CEF commit components. """
if not bool(self._cef_commit):
hash = git.get_hash(self.cef_path)
number = git.get_commit_number(self.cef_path)
self._cef_commit = {'HASH': hash, 'NUMBER': number}
return self._cef_commit
def get_cef_branch_version_components(self):
""" Computes the CEF branch version. """
if not bool(self._branch_version):
minor = 0
bugfix = 0
# Retrieve the list of commits that have been applied on the current
# branch since branching from origin/master.
hashes = git.get_branch_hashes(self.cef_path)
for hash in hashes:
# Determine if the API hash file was modified by the commit.
found = False
files = git.get_changed_files(self.cef_path, hash)
for file in files:
if file.find('cef_api_hash.h') >= 0:
found = True
break
if found:
minor += 1
bugfix = 0
else:
bugfix += 1
self._branch_version = {'MINOR': minor, 'PATCH': bugfix}
return self._branch_version
def get_chromium_version_string(self):
""" Returns the Chromium version number string. """
chrome_version = self.get_chrome_version_components()
return '%s.%s.%s.%s' % (chrome_version['MAJOR'], chrome_version['MINOR'],
chrome_version['BUILD'], chrome_version['PATCH'])
@staticmethod
def _format_commit_hash(hash):
return 'g%s' % hash[:7]
# Computes old version numbers in the format "X.YYYY.A.gHHHHHHH".
#
# Where:
# - "X" is the CEF major version (currently 3).
# - "YYYY" is the Chromium branch.
# - "A" is an incremental number representing the number of commits in the
# current branch. This is roughly equivalent to the SVN revision number but
# on a per-branch basis and assists people in quickly determining the order
# of builds in the same branch (for bug reports, etc).
# - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
# facilitates lookup of the relevant commit history in Git.
#
# Example: "3.3729.1921.g62d140e"
def _compute_old_version(self):
if not self._old_version_string is None:
return
chrome_version = self.get_chrome_version_components()
cef_version = self.get_cef_version_components()
cef_commit = self.get_cef_commit_components()
cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
self._old_version_parts = {
'MAJOR': int(cef_version['CEF_MAJOR']),
'MINOR': int(chrome_version['BUILD']),
'PATCH': int(cef_commit['NUMBER'])
}
self._old_version_string = \
'%s.%s.%s.%s' % (cef_version['CEF_MAJOR'], chrome_version['BUILD'],
cef_commit['NUMBER'], cef_commit_hash)
def _get_old_version_string(self):
self._compute_old_version()
return self._old_version_string
def _get_old_version_parts(self):
self._compute_old_version()
return self._old_version_parts
# Computes version numbers in the format:
# - "X.Y.Z+gHHHHHHH+chromium-A.B.C.D" for release branch builds.
# - "X.0.0-master.N+gHHHHHHH+chromium-A.B.C.D" for master branch builds.
#
# Where:
# - "X" is the Chromium major version (e.g. 74).
# - "Y" is an incremental number that starts at 0 when a release branch is
# created and changes only when the CEF C/C++ API changes (similar to how
# the CEF_API_HASH_UNIVERSAL value behaves in cef_version.h) (release branch
# only).
# - "Z" is an incremental number that starts at 0 when a release branch is
# created and changes on each commit, with reset to 0 when "Y" changes
# (release branch only).
# - "N" is an incremental number representing the number of commits (master
# branch only).
# - "gHHHHHHH" is the 7-character abbreviation for the Git commit hash. This
# facilitates lookup of the relevant commit history in Git.
# - "A.B.C.D" is the Chromium version (e.g. 74.0.3729.6).
#
# Examples:
# - "74.0.1+g62d140e+chromium-74.0.3729.6" for a release build.
# - "74.0.0-master.1920+g725ed88+chromium-74.0.3729.0" for a master build.
def _compute_version(self):
if not self._version_string is None:
return
chrome_version = self.get_chrome_version_components()
chrome_major = chrome_version['MAJOR']
chrome_version_part = 'chromium-' + self.get_chromium_version_string()
cef_commit = self.get_cef_commit_components()
cef_commit_hash = self._format_commit_hash(cef_commit['HASH'])
# Determine whether the current commit is on a release branch. For example,
# if using Chrome build 3683, are we on CEF branch "3683" or "origin/3683"?
release_branch = chrome_version['BUILD']
on_release_branch = (
git.is_ancestor(self.cef_path, 'HEAD', release_branch) or
git.is_ancestor(self.cef_path, 'HEAD', 'origin/' + release_branch))
if not on_release_branch:
# Not on a commit that is part of an official named release branch. See
# if we can get the name of the branch we are on (may be just "HEAD").
cef_branch_name = git.get_branch_name(self.cef_path).split('/')[-1]
self._version_parts = {'MAJOR': int(chrome_major), 'MINOR': 0, 'PATCH': 0}
self._version_string = '%s.0.0-%s.%s+%s+%s' % \
(chrome_major, cef_branch_name, cef_commit['NUMBER'],
cef_commit_hash, chrome_version_part)
else:
cef_branch = self.get_cef_branch_version_components()
self._version_parts = {
'MAJOR': int(chrome_major),
'MINOR': cef_branch['MINOR'],
'PATCH': cef_branch['PATCH']
}
self._version_string = '%s.%d.%d+%s+%s' % \
(chrome_major, cef_branch['MINOR'], cef_branch['PATCH'],
cef_commit_hash, chrome_version_part)
def _get_version_string(self):
self._compute_version()
return self._version_string
def _get_version_parts(self):
self._compute_version()
return self._version_parts
def get_version_string(self, oldFormat=None):
""" Returns the CEF version number string based on current checkout state.
"""
if oldFormat is None:
oldFormat = self._old_format_default
if oldFormat:
return self._get_old_version_string()
return self._get_version_string()
def get_version_parts(self, oldFormat=None):
""" Returns the CEF version number parts based on current checkout state.
"""
if oldFormat is None:
oldFormat = self._old_format_default
if oldFormat:
return self._get_old_version_parts()
return self._get_version_parts()
def get_plist_version_string(self, oldFormat=None):
""" Returns the CEF version number string for plist files based on current
checkout state. """
parts = self.get_version_parts(oldFormat=oldFormat)
return "%d.%d.%d.0" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'])
def get_dylib_version_string(self, oldFormat=None):
""" Returns the CEF version number string for dylib files based on current
checkout state. """
parts = self.get_version_parts(oldFormat=oldFormat)
# Dylib format supports a max value of 255 for the 2nd and 3rd components.
return "%d%d.%d.%d" % (parts['MAJOR'], parts['MINOR'], parts['PATCH'] / 255,
parts['PATCH'] % 255)
# Test the module.
if __name__ == "__main__":
import sys
# Optionally specify a format.
formats = ['current', 'old', 'plist', 'dylib']
if len(sys.argv) >= 2:
formats = [sys.argv[1]]
# Optionally specify the path to chromium/src.
chromium_src_path = None
if len(sys.argv) >= 3:
chromium_src_path = sys.argv[2]
formatter = VersionFormatter(chromium_src_path)
for format in formats:
if len(formats) > 1:
print(format)
if format == 'old':
print(formatter.get_version_string(True))
elif format == 'dylib':
print(formatter.get_dylib_version_string())
elif format == 'plist':
print(formatter.get_plist_version_string())
else:
print(formatter.get_version_string(False))
Reference in New Issue View Git Blame Copy Permalink