In 3GPP TS 29501, section 6.3, there's information about backwards compatible/incompatible API changes for 5G Core APIs.
What I'm not able to figure out if there's a clear cut rule for request/response payloads? Should a payload always be valid given the NFs version of the API schema for changes to be backwards compatible?
E.g. let's say there's an integer attribute "foo" restricted to values between 0 and 10 in version 1.0.0. If the interval is changed to values between 0 and 20 in a later version, is that considered backwards compatible or not?
If it is considered backwards compatible since 0-10 is covered by 0-20 it means that a consumer should accept values not valid based on it's own API version? (e.g. receiving foo=17).
In the latest version TS 29.501 V17.5.0 Annex B (Informative) Backward Incompatible Changes.
It states "Backward incompatible changes are additions or changes in the API that break the existing Service Consumer behaviour. "
In your example, if the consumer (e.g. UE) uses the new version with "0-20" while the producer (Network Provider) only supports the older version 1.0.0 "0-10", then I think it's not backward compatible bc the producer is unable to support a value larger than 10.
The opposite would be OK, if the older version 1.0.0 was initially "0-20" and then the new version "0-10", it would be covered and considered backward compatible.
Best regards
Related
Let’s imagine I have an iOS app. In version 2.0, I added a bunch of new features, but to implement them, I had to drop support for an older iOS version which is still in heavy use (remember, it’s a hypothetical scenario).
Later, I discovered a super critical bug in version 1.0 of my app that needs to be patched.
What are my options in terms of distribution?
It seems that it’s not possible to release version 1.0.1 if version 2.0 is already on the App Store. Adding back support for the older iOS version and fixing the bug in 2.0.1 is not feasible because that would require removal of the new features.
The problem here is that I can’t think of a way you could submit a version that updates version 1 without letting your version 2 users download it. So if you want to update version 1 you will just have to bite the bullet and meld your versions together. Use availability so that the new features are not present for your version 1 users.
Confluent's Schema Registry defined several compatiblity levels, which are richer than the compatibility checks that Avro provides.
However, although I understand the definitions for each compatibility level, I don't understand what sequence of schemas could be "fully compatible" but not "fully transitively compatible".
Could anyone provide an example of a sequence of schemas that fits that criteria?
The effect that transitive has is that it'll check all previous versions rather than only the current against the next inserted version.
I wouldn't call this "richer" per-say (the schema registry is still using the same Avro compatibility methods behind the scenes), it just is an improvement over the implicit transitivity that happens if you don't override the configuration in between two versions. (If v2 is compatible with v1, then v3 is compatible to v2, then you would assume v3 is compatible with v1)
I haven't used FULL, but let's say for example, you want to completely break the schema. You could have the default compatibility of BACKWARD (schema v1), then set to NONE and push a schema (v2), then again to BACKWARD. Now, if you push push a new schema (v3), only v2 would be checked against.
If you had set the transitive setting before v3, then v1 would have been checked as well as v2.
In upgrading from SCDF 1.1.1.RELEASE to 1.2.4.RELEASE, are there any database schema changes that I would need to be concerned about?
Specifically, if I'm already running SCDF 1.1.1.RELEASE on a Pivotal Cloudfoundry platform, and using a MySQL service tile as the underlying database, will the stream, app, and task metadata that is already in the database translate readily to SCDF upgraded to 1.2.4.RELEASE?
What other potential concerns might I need to take a close look at as I plan to upgrade?
Yes, as documented on the official docs: https://docs.spring.io/spring-cloud-dataflow/docs/1.2.3.RELEASE/reference/htmlsingle/#configuration-rdbms
Apart from the migration-script, there shouldn't be any other concerns wrt upgrade. At least in 1.1 -> 1.2, there's simply a case-conversion of a Task table name, which shouldn't impact existing records or any other functionalities.
That said, 1.2.4 is an old release. Please consider switching over to 1.3 GA release at the earliest. This release includes migration scripts as well, but again, we make sure to not introduce breaking changes in the minor releases (e.g., 1.2 -> 1.3), so switching to 1.3 should be straightforward.
Here's a roundup of all the new features available in the latest 1.3 release.
I have an Android app with versionName=1.0.5 and versionNumber=7 in Android Manifest.xml file. Whenever I repackage my app the vesionName automatically changes to 1.0.7.0. I have no idea why it does this. I want my application versionName to be same as in the Android Manifest.xml file.
Further to your comment, the convention on BlackBerry platforms is (as you say) to use a dotted quad as the version name. For the sake of discussion lets call the four numbers:
Major
Minor
Release
Build
The Major number indicates very significant changes that will often preclude working on older hardware. BBOS 4, 5, 6, 7, 10 are examples of this. A device released to run OS N will usually not be able to run OS N+1.
The Minor numbers indicate significant changes. These are often additional APIs or capabilities but don't usually indicate hardware incompatibilities. For example versions 10.0, 10.1, 10.2 and 10.3.
The Release number indicates changes which are fixes or minor enhancements but don't normally come with major new features or APIs.
The Build number is a one-up number incremented each time the product with a particular Major.Minor.Release is built. It is normal for these numbers to reach the hundreds or thousands before a product is released.
Clearly given a versionNumber to put in the version string with versionName it doesn't make sense to put it in the build field. The Release field makes the most sense.
What is the difference between an SDK that is "deprecated" and one that is "unsupported"?
I am asking in the context of developing javascript applications for Rally - I was fixing up an old application when I noticed the SDK will become unsupported in under 2 months. Does this mean the app will no longer work at all when the SDK becomes unsupported? Thanks
As I know, unsupported means that a function has thrown away and now it is not available. Deprecated, it means that a function is available but at the future will become unsupported. For unsupported/deprecated "things" almost always exists a new version of this with a different name( and maybe different parameters). You must not use deprecated functions or other staff.
Therefore, check for available updates and upgrades for your SDK, to make sure that your app will keep running and check for other implementations of the things that you are using.