Subversion Repositories DevTools

Rev

Rev 7093 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7093 Rev 7094
Line 387... Line 387...
387 
 
 387 
 
388 
    /**
 388 
    /**
389 
     * Constructor
 389 
     * Constructor
390 
     * Used to create planned packages (WIP). In these packages the change_type is significant
 390 
     * Used to create planned packages (WIP). In these packages the change_type is significant
391 
     *
391 
     *
392 
     * @param pkg_id	   Package Name Identifier
 392 
     * @param pkgId	   Package Name Identifier
393 
     * @param pv_id        Package Version Id
 393 
     * @param pvId        Package Version Id
394 
     * @param pkg_name     Package Name
 394 
     * @param pkgName     Package Name
395 
     * @param pkg_version  Package Version
 395 
     * @param pkgVersion  Package Version
396 
     * @param v_ext        Package Suffix
 396 
     * @param vExt        Package Suffix
397 
     * @param alias        Package Alias
 397 
     * @param alias        Package Alias
398 
     * @param pkg_vcs_tag  Vcs Tag
 398 
     * @param pkgVcsTag  Vcs Tag
399 
     * @param ripple_field Ripple Field
 399 
     * @param rippleField Ripple Field
400 
     * @param change_type  Change Type
 400 
     * @param changeType  Change Type
401 
     */
 401 
     */
402 
    public Package(int pkg_id, int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field, char change_type)
 402 
    public Package(int pkgId, int pvId, String pkgName, String pkgVersion, String vExt, String alias, String pkgVcsTag, char rippleField, char changeType)
403 
    {
 403 
    {
404 
        mLogger.error("Package 1: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} change_type {}", pv_id, pkg_name,v_ext,alias, pkg_vcs_tag, change_type);
 404 
        mLogger.debug("Package 1: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} ripple_field {} change_type {}", pvId, pkgName,vExt,alias, pkgVcsTag, rippleField, changeType);
405 
        mId = pv_id;
 405 
        mId = pvId;
406 
        mName = pkg_name;
 406 
        mName = pkgName;
407 
        mPid = pkg_id;
 407 
        mPid = pkgId;
408 
        mVersion = "0.0.0000";
 408 
        mVersion = "0.0.0000";
409 
        mExtension = v_ext;
 409 
        mExtension = vExt;
410 
        mAlias = alias;
 410 
        mAlias = alias;
411 
        mVcsTag = pkg_vcs_tag;
 411 
        mVcsTag = pkgVcsTag;
412 
 
 412 
 
413 
        // Remove the package suffix from package_version to create the fixed version number
 413 
        // Remove the package suffix from package_version to create the fixed version number
414 
        mFixedVersion = pkg_version;
 414 
        mFixedVersion = pkgVersion;
415 
        mFixedVersion = mFixedVersion.substring(0, mFixedVersion.length() - mExtension.length());
 415 
        mFixedVersion = mFixedVersion.substring(0, mFixedVersion.length() - mExtension.length());
416 
 
 416 
 
417 
        // a ripple_field of 'L' indicates this package has limited version numbering
 417 
        // a ripple_field of 'L' indicates this package has limited version numbering
418 
        if (change_type == 'M') {
 418 
        if (changeType == 'M') {
419 
            mChangeType.setMajor(ripple_field == 'L' ? true : false);
 419 
            mChangeType.setMajor(rippleField == 'L' ? true : false);
420
420
421 
        } else if (change_type == 'N') {
 421 
        } else if (changeType == 'N') {
422 
            mChangeType.setMinor(ripple_field == 'L' ? true : false);
 422 
            mChangeType.setMinor(rippleField == 'L' ? true : false);
423
423
424 
        } else if (change_type == 'P') {
 424 
        } else if (changeType == 'P') {
425 
            mChangeType.setPatch(ripple_field == 'L' ? true : false);
 425 
            mChangeType.setPatch(rippleField == 'L' ? true : false);
426
426
427 
        } else if (change_type == 'F') {
 427 
        } else if (changeType == 'F') {
428 
            mChangeType.setFixed();
 428 
            mChangeType.setFixed();
429
429
430 
        } else {
 430 
        } else {
431 
            mChangeType.setUnknown();
 431 
            mChangeType.setUnknown();
432 
        }
 432 
        }
Line 434... Line 434...
434 
 
 434 
 
435 
    /**
 435 
    /**
436 
     * Constructor
 436 
     * Constructor
437 
     * Used to create existing packages, in these packages the ripple_field is significant
 437 
     * Used to create existing packages, in these packages the ripple_field is significant
438 
     *
438 
     *
439 
     * @param pkg_id	   Package Name Identifier
 439 
     * @param pkgId	   Package Name Identifier
440 
     * @param pv_id        Package Version Id
 440 
     * @param pvId        Package Version Id
441 
     * @param pkg_name     Package Name
 441 
     * @param pkgName     Package Name
442 
     * @param pkg_version  Package Version
 442 
     * @param pkgVersion  Package Version
443 
     * @param v_ext        Package Suffix
 443 
     * @param vExt        Package Suffix
444 
     * @param alias        Package Alias
 444 
     * @param alias        Package Alias
445 
     * @param pkg_vcs_tag  Vcs Tag
 445 
     * @param pkgVcsTag  Vcs Tag
446 
     * @param ripple_field Ripple Field
 446 
     * @param rippleField Ripple Field
447 
     */
 447 
     */
448 
    public Package(int pkg_id,int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field)
 448 
    public Package(int pkgId,int pvId, String pkgName, String pkgVersion, String vExt, String alias, String pkgVcsTag, char rippleField)
449 
    {
 449 
    {
450 
        mLogger.debug("Package 2: pv_id " + pv_id + " pkg_name " + pkg_name + " pkg_version " + pkg_version + " v_ext "
 450 
        mLogger.debug("Package 2: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} ripple_field {}", pvId, pkgName,vExt,alias, pkgVcsTag, rippleField);
451 
                + v_ext + " alias " + alias + " pkg_vcs_tag " + pkg_vcs_tag + " ripple_field " + ripple_field);
 - 
 
452 
        mId = pv_id;
 451 
        mId = pvId;
453 
        mName = pkg_name;
 452 
        mName = pkgName;
454 
        mPid = pkg_id;
 453 
        mPid = pkgId;
455 
        mVersion = pkg_version;
 454 
        mVersion = pkgVersion;
456 
        int endindex = mVersion.length() - v_ext.length();
 455 
        int endindex = mVersion.length() - vExt.length();
457 
 
 456 
 
458 
        if (endindex > 0)
 457 
        if (endindex > 0)
459 
        {
 458 
        {
460 
            mVersion = mVersion.substring(0, endindex);
 459 
            mVersion = mVersion.substring(0, endindex);
461 
        }
 460 
        }
462 
 
 461 
 
463 
        mExtension = v_ext;
 462 
        mExtension = vExt;
464 
        mAlias = alias;
 463 
        mAlias = alias;
465 
        mVcsTag = pkg_vcs_tag;
 464 
        mVcsTag = pkgVcsTag;
466 
 
 465 
 
467 
        // setBuild is the default
 466 
        // setBuild is the default
468 
        if (ripple_field == 'M') {
 467 
        if (rippleField == 'M') {
469 
            mRippleField.setMajor();
 468 
            mRippleField.setMajor();
470
469
471 
        } else if (ripple_field == 'm') {
 470 
        } else if (rippleField == 'm') {
472 
            mRippleField.setMinor();
 471 
            mRippleField.setMinor();
473
472
474 
        } else if (ripple_field == 'p') {
 473 
        } else if (rippleField == 'p') {
475 
            mRippleField.setPatch();
 474 
            mRippleField.setPatch();
476
475
477 
        } else if (ripple_field == 'L') {
 476 
        } else if (rippleField == 'L') {
478 
            mRippleField.setLimit();
 477 
            mRippleField.setLimit();
479 
        }
 478 
        }
480 
    }
 479 
    }
481 
 
 480 
 
482 
    /**
 481 
    /**
Line 789... Line 788...
789 
     */
 788 
     */
790
789
791 
    int applyPV(ReleaseManager releaseManager) throws Exception
 790 
    int applyPV(ReleaseManager releaseManager) throws Exception
792 
    {
 791 
    {
793 
        String logInfo = "applyPV," + mName;
 792 
        String logInfo = "applyPV," + mName;
- 
 
 793 
        String changeType = "";
794 
        mLogger.error("applyPV on Package {}", mName);
 794 
        mLogger.error("applyPV on Package {}", mName);
795
795
796 
        //
 796 
        //
797 
        //  This method used to actually perform the version change
 797 
        //  This method used to actually perform the version change
798 
        //  Now it just calculates the potential value
 798 
        //  Now it just calculates the potential value
Line 922... Line 922...
922 
        // mChangeType overrides mRippleField
 922 
        // mChangeType overrides mRippleField
923 
        do
 923 
        do
924 
        {
 924 
        {
925 
            if (mChangeType.mMajor)
 925 
            if (mChangeType.mMajor)
926 
            {
 926 
            {
927 
                logInfo += ",CT Major";
 927 
                changeType = ",CT Major";
928 
                if (!incrementFieldsAccordingToLimits(4, major, minor, patch))
 928 
                if (!incrementFieldsAccordingToLimits(4, major, minor, patch))
929 
                {
 929 
                {
930 
                    mLogger.info("applyPv returned 2");
 930 
                    mLogger.info("applyPv returned 2");
931 
                    mVersion = originalVersion;
 931 
                    mVersion = originalVersion;
932 
                    return 2;
 932 
                    return 2;
933 
                }
 933 
                }
934 
            } else if (mChangeType.mMinor)
 934 
            } else if (mChangeType.mMinor)
935 
            {
 935 
            {
936 
                logInfo += ",CT Minor";
 936 
                changeType = ",CT Minor";
937 
                if (!incrementFieldsAccordingToLimits(3, major, minor, patch))
 937 
                if (!incrementFieldsAccordingToLimits(3, major, minor, patch))
938 
                {
 938 
                {
939 
                    mLogger.info("applyPv returned 2");
 939 
                    mLogger.info("applyPv returned 2");
940 
                    mVersion = originalVersion;
 940 
                    mVersion = originalVersion;
941 
                    return 2;
 941 
                    return 2;
942 
                }
 942 
                }
943 
            } else if (mChangeType.mPatch)
 943 
            } else if (mChangeType.mPatch)
944 
            {
 944 
            {
945 
                logInfo += ",CT Patch";
 945 
                changeType = ",CT Patch";
946 
                if (!incrementFieldsAccordingToLimits(2, major, minor, patch))
 946 
                if (!incrementFieldsAccordingToLimits(2, major, minor, patch))
947 
                {
 947 
                {
948 
                    mLogger.info("applyPv returned 2");
 948 
                    mLogger.info("applyPv returned 2");
949 
                    mVersion = originalVersion;
 949 
                    mVersion = originalVersion;
950 
                    return 2;
 950 
                    return 2;
951 
                }
 951 
                }
952 
            } else
 952 
            } else
953 
            {
 953 
            {
954 
                if (mRippleField.mMajor)
 954 
                if (mRippleField.mMajor)
955 
                {
 955 
                {
956 
                    logInfo += ",R Major";
 956 
                    changeType = ",R Major";
957 
                    major.value++;
 957 
                    major.value++;
958 
                    mLogger.info("applyPV mRippleField.mMajor {}", major.value);
 958 
                    mLogger.info("applyPV mRippleField.mMajor {}", major.value);
959 
                    minor.value = 0;
 959 
                    minor.value = 0;
960 
                    patch.value = 0;
 960 
                    patch.value = 0;
961 
                } else if (mRippleField.mMinor)
 961 
                } else if (mRippleField.mMinor)
962 
                {
 962 
                {
963 
                    logInfo += ",R Minor";
 963 
                    changeType = ",R Minor";
964 
                    minor.value++;
 964 
                    minor.value++;
965 
                    mLogger.info("applyPV mRippleField.mMinor {}", minor.value);
 965 
                    mLogger.info("applyPV mRippleField.mMinor {}", minor.value);
966 
                    patch.value = 0;
 966 
                    patch.value = 0;
967 
                } else if (mRippleField.mPatch)
 967 
                } else if (mRippleField.mPatch)
968 
                {
 968 
                {
969 
                    logInfo += ",R Patch";
 969 
                    changeType = ",R Patch";
970 
                    patch.value = ((patch.value / 1000) + 1) * 1000;
970 
                    patch.value = ((patch.value / 1000) + 1) * 1000;
971 
                    mLogger.info("applyPV mRippleField.mPatch {}", patch.value);
 971 
                    mLogger.info("applyPV mRippleField.mPatch {}", patch.value);
972 
                } else if (mRippleField.mBuild)
 972 
                } else if (mRippleField.mBuild)
973 
                {
 973 
                {
974 
                    logInfo += ", R Build";
 974 
                    changeType = ", R Build";
975 
                    patch.value++;
 975 
                    patch.value++;
976 
                    mLogger.info("applyPV mRippleField.mBuild {}", patch.value);
 976 
                    mLogger.info("applyPV mRippleField.mBuild {}", patch.value);
977 
                } else
 977 
                } else
978 
                {
 978 
                {
979 
                    if (!incrementFieldsAccordingToLimits(1, major, minor, patch))
 979 
                    if (!incrementFieldsAccordingToLimits(1, major, minor, patch))
Line 1005... Line 1005...
1005 
            }
 1005 
            }
1006 
 
 1006 
 
1007 
            mVersion += String.valueOf(patch.value);
 1007 
            mVersion += String.valueOf(patch.value);
1008 
        } while (exists(releaseManager));
 1008 
        } while (exists(releaseManager));
1009 
 
 1009 
 
1010 
        logInfo += ", Next Version:" + mVersion;
 1010 
        logInfo += changeType + ", Next Version:" + mVersion;
1011 
        mLogger.error(logInfo);
 1011 
        mLogger.error(logInfo);
1012 
        mLogger.info("applyPv returned 0");
 1012 
        mLogger.info("applyPv returned 0");
1013 
        mNextVersion = mVersion;
 1013 
        mNextVersion = mVersion;
1014 
        mVersion = originalVersion;
 1014 
        mVersion = originalVersion;
1015 
        return 0;
 1015 
        return 0;