Support new version policy for deb and rpm deps

Add Tarantool dependency to rpm or deb package only if it is not set up
by user explicitly with --deps or --deps-file. Use version struct
to build minimal and maximal requirements for packages based on new
version policy. Old version policy (2.8 and less) cases are considered
separately. Version struct parsing is strict so "lazy" versions without
number of commits since tag and commit hash (like "2.8.0") are no longer
supported since real Tarantool packages always have them. Use
struct-based approach in integration tests, migrate them to new version
policy.

Part of #619

Author: DifferentialOrange

cli/commands/pack.go

@@ -57,22 +57,62 @@ func init() {
 	packCmd.Flags().StringVar(&ctx.Pack.SystemdUnitParamsPath, "unit-params-file", "", UnitParamsFileUsage)
 }
 
+// isExplicitTarantoolDeps returns true if Tarantool was set up by user as a dependency
+// with --deps or --deps-file, false otherwise.
+func isExplicitTarantoolDeps(deps common.PackDependencies) bool {
+	for _, v := range deps {
+		if v.Name == "tarantool" {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Tarantool dependence is added to rpm and deb packages deps, if it
+// wasn't set up explicitly. Dependency conditions is chosen based on
+// tarantool version used in cartridge-cli environment. Since development
+// builds and entrypoint builds normally are not available in package repos,
+// they are not supported as rpm/deb dependency. Minimal required version
+// is environment tarantool version, maximum is next tarantool major version.
+// Both modern and <= 2.8 version policies are supported.
 func addTarantoolDepIfNeeded(ctx *context.Ctx) error {
-	if ctx.Tarantool.TarantoolIsEnterprise || !(ctx.Pack.Type == pack.RpmType || ctx.Pack.Type == pack.DebType) {
+	var version common.TarantoolVersion
+	var minVersion, maxVersion string
+	var err error
+
+	if isExplicitTarantoolDeps(ctx.Pack.Deps) {
 		return nil
 	}
 
-	var tarantoolVersion string
-	if ctx.Pack.Type == pack.RpmType {
-		tarantoolVersion = strings.SplitN(ctx.Tarantool.TarantoolVersion, "-", 2)[0]
-	} else if ctx.Pack.Type == pack.DebType {
-		tarantoolVersion = ctx.Tarantool.TarantoolVersion
+	if ctx.Tarantool.TarantoolIsEnterprise {
+		return nil
 	}
 
-	if err := ctx.Pack.Deps.AddTarantool(tarantoolVersion); err != nil {
-		return fmt.Errorf("Failed to get tarantool dependency: %s", err)
+	if (ctx.Pack.Type != pack.RpmType) && (ctx.Pack.Type != pack.DebType) {
+		return nil
+	}
+
+	if version, err = common.ParseTarantoolVersion(ctx.Tarantool.TarantoolVersion); err != nil {
+		return err
+	}
+
+	if version.IsDevelopmentBuild {
+		return fmt.Errorf("Development build found. If you want to use Tarantool development build" +
+			"as a dependency, set it up explicitly with --deps or --deps-file")
+	}
+
+	if version.TagSuffix == "entrypoint" {
+		return fmt.Errorf("Entrypoint build found. If you want to use Tarantool entrypoint build" +
+			"as a dependency, set it up explicitly with --deps or --deps-file")
+	}
+
+	if minVersion, err = common.GetMinimalRequiredVersion(version); err != nil {
+		return err
 	}
+	maxVersion = common.GetNextMajorVersion(version)
 
+	ctx.Pack.Deps.AddTarantool(minVersion, maxVersion)
 	return nil
 }
 

cli/common/tarantool.go

@@ -170,16 +170,32 @@ func GetMajorMinorVersion(version string) string {
 	return majorMinorVersion
 }
 
-// GetNextMajorVersion computes next major version for a given one.
-// For example, for 1.10.3 it's 2
-func GetNextMajorVersion(versionStr string) (string, error) {
-	version, err := goVersion.NewSemver(versionStr)
-	if err != nil {
-		return "", fmt.Errorf("Failed to parse Tarantool version: %s", err)
+// GetMinimalRequiredVersion computes minimal required Tarantool version for a package (rpm, deb).
+func GetMinimalRequiredVersion(ver TarantoolVersion) (string, error) {
+	// Old-style package version policy allowed X.Y.Z-N versions for N > 0 .
+	if (ver.Major == 2 && ver.Minor <= 8) || (ver.Major < 2) {
+		return fmt.Sprintf("%d.%d.%d.%d", ver.Major, ver.Minor, ver.Patch, ver.CommitsSinceTag), nil
+	}
+
+	if ver.IsDevelopmentBuild {
+		return "", fmt.Errorf("Can't compute minimal required version for a development build")
+	}
+
+	if ver.TagSuffix == "entrypoint" {
+		return "", fmt.Errorf("Can't compute minimal required version for an entrypoint build")
 	}
 
-	major := version.Segments()[0]
-	return strconv.Itoa(major + 1), nil
+	if ver.TagSuffix != "" {
+		return fmt.Sprintf("%d.%d.%d~%s", ver.Major, ver.Minor, ver.Patch, ver.TagSuffix), nil
+	}
+
+	return fmt.Sprintf("%d.%d.%d", ver.Major, ver.Minor, ver.Patch), nil
+}
+
+// GetNextMajorVersion computes next Major version for a given one.
+// For example, for 1.10.3 it's 2 .
+func GetNextMajorVersion(ver TarantoolVersion) string {
+	return strconv.Itoa(int(ver.Major) + 1)
 }
 
 func GetCartridgeVersionStr(conn *connector.Conn) (string, error) {

cli/common/tarantool_test.go

@@ -283,3 +283,47 @@ func TestParseTarantoolVersion(t *testing.T) {
 		}
 	}
 }
+
+type returnValueGetMinimalRequiredVersion struct {
+	res string
+	err error
+}
+
+func TestGetTarantoolMinVersion(t *testing.T) {
+	assert := assert.New(t)
+
+	testCases := map[string]returnValueGetMinimalRequiredVersion{
+		"3.0.0-rc1-0-g7da4b1438":    {res: "3.0.0~rc1", err: nil},
+		"2.10.0-beta1-0-g7da4b1438": {res: "2.10.0~beta1", err: nil},
+		"2.10.0-0-g7da4b1438":       {res: "2.10.0", err: nil},
+		"2.9.0-alpha1-0-g7da4b1438": {res: "2.9.0~alpha1", err: nil},
+		"2.8.2-0-gfc96d10f5":        {res: "2.8.2.0", err: nil},
+		"1.10.11-21-g543e2a1ec0":    {res: "1.10.11.21", err: nil},
+
+		"2.10.1-entrypoint-0-gc2438eeb1": {
+			res: "",
+			err: fmt.Errorf("Can't compute minimal required version for an entrypoint build"),
+		},
+		"2.10.1-23-g0c2e2a1ec-dev": {
+			res: "",
+			err: fmt.Errorf("Can't compute minimal required version for a development build"),
+		},
+		"2.10.0-beta1-3-g4b17da438-dev": {
+			res: "",
+			err: fmt.Errorf("Can't compute minimal required version for a development build"),
+		},
+	}
+
+	for version, output := range testCases {
+		ver, verErr := ParseTarantoolVersion(version)
+		assert.Nil(verErr)
+
+		res, err := GetMinimalRequiredVersion(ver)
+		if output.err == nil {
+			assert.Nil(err)
+			assert.Equal(output.res, res)
+		} else {
+			assert.Equal(output.err, err)
+		}
+	}
+}

cli/common/utils.go

@@ -34,28 +34,20 @@ type PackDependency struct {
 
 type PackDependencies []PackDependency
 
-func (deps *PackDependencies) AddTarantool(tarantoolVersion string) error {
-	tarantoolMinVersion := tarantoolVersion
-	tarantoolMaxVersion, err := GetNextMajorVersion(tarantoolMinVersion)
-	if err != nil {
-		return fmt.Errorf("Failed to get next major version of Tarantool %s", err)
-	}
-
+func (deps *PackDependencies) AddTarantool(minVersion, maxVersion string) {
 	*deps = append(*deps, PackDependency{
 		Name: "tarantool",
 		Relations: []DepRelation{
 			{
 				Relation: ">=",
-				Version:  tarantoolMinVersion,
+				Version:  minVersion,
 			},
 			{
 				Relation: "<",
-				Version:  tarantoolMaxVersion,
+				Version:  maxVersion,
 			},
 		},
 	})
-
-	return nil
 }
 
 var bufSize int64 = 10000

test/integration/pack/test_pack.py

@@ -21,8 +21,8 @@
                    check_param_in_unit_files, clear_project_rocks_cache,
                    extract_app_files, extract_deb, extract_rpm, find_archive,
                    get_rocks_cache_path, get_rockspec_path, recursive_listdir,
-                   run_command_and_get_output, tarantool_enterprise_is_used,
-                   tarantool_version, validate_version_file)
+                   run_command_and_get_output, tarantool_dict_version,
+                   tarantool_enterprise_is_used, validate_version_file)
 
 
 # ########
@@ -99,13 +99,19 @@ def deb_archive(cartridge_cmd, tmpdir, light_project, request):
 
 @pytest.fixture(scope="session")
 def tarantool_versions():
-    min_deb_version = re.findall(r'\d+\.\d+\.\d+-\d+-\S+', tarantool_version())[0]
-    max_deb_version = str(int(re.findall(r'\d+', tarantool_version())[0]) + 1)
-    min_rpm_version = re.findall(r'\d+\.\d+\.\d+', tarantool_version())[0]
-    max_rpm_version = max_deb_version  # Their format is the same
+    ver = tarantool_dict_version()
+    if (ver['Major'] == 2 and ver['Minor'] <= 8) or (ver['Major'] < 2):
+        min_version = f"{ver['Major']}.{ver['Minor']}.{ver['Patch']}.{ver['CommitsSinceTag']}"
+    else:
+        if ver['TagSuffix'] is not None:
+            min_version = f"{ver['Major']}.{ver['Minor']}.{ver['Patch']}~{ver['TagSuffix']}"
+        else:
+            min_version = f"{ver['Major']}.{ver['Minor']}.{ver['Patch']}"
+
+    max_version = f"{ver['Major'] + 1}"
 
-    return {"min": {"deb": min_deb_version, "rpm": min_rpm_version},
-            "max": {"deb": max_deb_version, "rpm": max_rpm_version}}
+    return {"min": {"deb": min_version, "rpm": min_version},
+            "max": {"deb": max_version, "rpm": max_version}}
 
 
 # #####
@@ -134,7 +140,7 @@ def test_tgz(tgz_archive, tmpdir):
         assert_filemodes(project, extract_dir)
 
 
-def test_rpm(rpm_archive, tmpdir):
+def test_rpm(rpm_archive, tmpdir, tarantool_versions):
     project = rpm_archive.project
 
     # archive files should be extracted to the empty directory
@@ -145,7 +151,7 @@ def test_rpm(rpm_archive, tmpdir):
     extract_rpm(rpm_archive.filepath, extract_dir)
 
     if not tarantool_enterprise_is_used():
-        assert_tarantool_dependency_rpm(rpm_archive.filepath)
+        assert_tarantool_dependency_rpm(rpm_archive.filepath, tarantool_versions)
 
     check_package_files(project, extract_dir)
     assert_files_mode_and_owner_rpm(project, rpm_archive.filepath)
@@ -158,7 +164,7 @@ def test_rpm(rpm_archive, tmpdir):
     assert process.returncode == 0, "RPM signature isn't correct"
 
 
-def test_deb(deb_archive, tmpdir):
+def test_deb(deb_archive, tmpdir, tarantool_versions):
     project = deb_archive.project
 
     # archive files should be extracted to the empty directory
@@ -191,7 +197,7 @@ def test_deb(deb_archive, tmpdir):
             assert os.path.exists(os.path.join(control_dir, filename))
 
         if not tarantool_enterprise_is_used():
-            assert_tarantool_dependency_deb(os.path.join(control_dir, 'control'))
+            assert_tarantool_dependency_deb(os.path.join(control_dir, 'control'), tarantool_versions)
 
         # check if postinst script set owners correctly
         with open(os.path.join(control_dir, 'postinst')) as postinst_script_file:

test/utils.py

@@ -532,19 +532,16 @@ def assert_dependencies_deb(filename, deps, tarantool_versions, tmpdir):
     assert all(dep in output for dep in deps)
 
 
-def assert_tarantool_dependency_deb(filename):
+def assert_tarantool_dependency_deb(filename, tarantool_versions):
     with open(filename) as control:
         control_info = control.read()
 
         depends_str = re.search('Depends: (.*)', control_info)
         assert depends_str is not None
 
-        min_version = re.findall(r'\d+\.\d+\.\d+-\d+-\S+', tarantool_version())[0]
-        max_version = str(int(re.findall(r'\d+', tarantool_version())[0]) + 1)
-
         deps = depends_str.group(1)
-        assert 'tarantool (>= {})'.format(min_version) in deps
-        assert 'tarantool (<< {})'.format(max_version) in deps
+        assert 'tarantool (>= {})'.format(tarantool_versions["min"]["deb"]) in deps
+        assert 'tarantool (<< {})'.format(tarantool_versions["max"]["deb"]) in deps
 
 
 def assert_dependencies_rpm(filename, deps, tarantool_versions):
@@ -569,7 +566,7 @@ def assert_dependencies_rpm(filename, deps, tarantool_versions):
             assert rpm.headers['requireversion'][i].decode('ascii') == dep[2]
 
 
-def assert_tarantool_dependency_rpm(filename):
+def assert_tarantool_dependency_rpm(filename, tarantool_versions):
     with rpmfile.open(filename) as rpm:
         dependency_keys = ['requirename', 'requireversion', 'requireflags']
         for key in dependency_keys:
@@ -579,15 +576,12 @@ def assert_tarantool_dependency_rpm(filename):
         assert len(rpm.headers['requireversion']) == 2
         assert len(rpm.headers['requireflags']) == 2
 
-        min_version = re.findall(r'\d+\.\d+\.\d+', tarantool_version())[0]
-        max_version = str(int(re.findall(r'\d+', tarantool_version())[0]) + 1)
-
         assert rpm.headers['requirename'][0].decode('ascii') == 'tarantool'
-        assert rpm.headers['requireversion'][0].decode('ascii') == min_version
+        assert rpm.headers['requireversion'][0].decode('ascii') == tarantool_versions["min"]["rpm"]
         assert rpm.headers['requireflags'][0] == 0x08 | 0x04  # >=
 
         assert rpm.headers['requirename'][1].decode('ascii') == 'tarantool'
-        assert rpm.headers['requireversion'][1].decode('ascii') == max_version
+        assert rpm.headers['requireversion'][1].decode('ascii') == tarantool_versions["max"]["rpm"]
         assert rpm.headers['requireflags'][1] == 0x02  # <
 
 
@@ -1394,3 +1388,36 @@ def get_response_data(response):
     assert 'errors' not in response_json, response_json
 
     return response_json['data']
+
+
+def parse_tarantool_version(s):
+    regstr = (r'^Tarantool\s(?:Enterprise\s)?' +
+              r'(?P<Major>\d+)\.(?P<Minor>\d+)?\.(?P<Patch>\d+)' +
+              r'(?:-(?P<TagSuffix>alpha\d+|beta\d+|rc\d+|entrypoint))?' +
+              r'-(?P<CommitsSinceTag>\d+)-(?P<CommitHashId>g[0-9a-f]+)' +
+              r'(?:-(?P<EnterpriseSDKRevision>r\d+)(?:-(?P<EnterpriseIsOnMacOS>macos))?)?' +
+              r'(?:-(?P<IsDevelopmentBuild>dev))?$')
+
+    r = re.match(regstr, s)
+    assert r is not None
+    ver = r.groupdict()
+    assert len(ver) != 0
+
+    ver['Major'] = int(ver['Major'])
+    ver['Minor'] = int(ver['Minor'])
+    ver['Patch'] = int(ver['Patch'])
+    ver['CommitsSinceTag'] = int(ver['CommitsSinceTag'])
+    ver['EnterpriseIsOnMacOS'] = (ver['EnterpriseIsOnMacOS'] is not None)
+    ver['IsDevelopmentBuild'] = (ver['IsDevelopmentBuild'] is not None)
+
+    return ver
+
+
+def tarantool_dict_version():
+    s = tarantool_version()
+    ver = parse_tarantool_version(s)
+
+    assert ver['TagSuffix'] != 'entrypoint'
+    assert ver['IsDevelopmentBuild'] is False
+
+    return ver