[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]
Subject: JAVA-98: Updated proposed direction for resolution
Here is a revised and consolidated version of the previous proposed direction for resolution, including the examples and Dave's comments. I am hoping that on today's call the TC will vote to accept this as a direction for resolving JAVA-98. I would then be able to produce a full proposal with inline updates to the specification text, and distribute it later today so that we can consider it on Monday's call. A) Specific intent annotations can appear together with @Requires on the same Java program element. If they do, the annotations contributed by specific intent annotations are merged with those contributed by @Requires, following the policy rules for merging intents at the same hierarchy level. Intents can be applied to the following: . a Java interface used as an SCA service interface, and the methods of such an interface . a Java class used both as an SCA service implementation and a service interface, and the methods of such a class . a Java class used only as an SCA service implementation . a Java reference . a Java interface for a reference . the methods of a Java interface for a reference It is an error to apply an intent to a method of a Java class used only as an SCA service implementation. B) The effective intents for a method of an SCA interface defined by <interface.java> are computed by the following algorithm: 1. Use the rules in A) above to find the intents for the method and the intents for its declaring class or interface. 2. Use the policy rules for merging intents within a structural hierarchy to merge the intents found in step 1 above, with the method at the lower level and the method's declaring class or interface at the higher level. These rules are applied to the following: . the methods of a Java interface used as an SCA service interface . the methods of a Java class used both as an SCA service implementation and a service interface . the methods of a Java interface for a reference The merging process does not remove or change any intents that were applied to classes or interfaces. C) The effective intents for each method of an SCA service are computed by applying the rules in the Policy specification to the intropected component type implied by the rules in D) below, using the effective intent computation rules in B) above. D) The componentType introspection rules for intents are as follows: 1. Intents on the service implementation class are placed on the <implementation.java> element in the componentType. 2. For all SCA services defined using Java interfaces, intents on the service implementation class are placed on the corresponding <service> elements in the componentType. 3. Intents on Java references are placed on the corresponding <reference> elements in the componentType. The following examples show how the various points of this proposal would work. In these examples, it is assumed that @ManagedTransaction has been defined as a specific intent annotation for the SCA intent "managedTransaction". No examples are given for point C) above because this delegates to the Policy spec and is not Java-specific. Example A1: In the following Java code, the intents on myref are "authentication" and "confidentiality.message". @Authentication @Requires(CONFIDENTIALITY) @Confidentiality("message") @Reference protected MyService myref; Example A2: The following Java code is in error because of contradictory mutually exclusive intents "managedTransaction" and "noManagedTransaction". @ManagedTransaction @Requires(SCA_PREFIX+"noManagedTransaction") @Reference protected MyService myref; Example A3: The following intents are legal: @Authentication public class MyService { @Confidentiality public void mymethod() {...} } Example A4: The following intents are legal: @Authentication public interface MyService { @Confidentiality public void mymethod(); } @Service(MyService.class) @ManagedTransaction public class MyServiceImpl { public void mymethod() {...} } Example A5: The following intents are legal: @Authentication public interface MyRefInt { @Integrity public void mymethod(); } @Service(MyService.class) public class MyServiceImpl { @Confidentiality @Reference protected MyRefInt myRef; } Example A6: The following intent is illegal: @Service(MyService.class) public class MyServiceImpl { @Authentication public void mymethod() {...} } Example B1: The effective intents for mymethod() are "authentication" and "confidentiality". @Authentication public interface MyService { @Confidentiality public void mymethod(); } Example B2: The effective intent for mymethod() is "confidentiality.message". @Confidentiality("message") public interface MyService { @Confidentiality public void mymethod(); } Example B3: The effective intent for mymethod1() is "managedTransaction" and the effective intent for mymethod2() is "noManagedTransaction". @ManagedTransaction public interface MyService { public void mymethod1(); @Requires(SCA_PREFIX+"noManagedTransaction") public void mymethod2(); } Example D1: For the following Java code: @Authentication public interface MyService { @Confidentiality public void mymethod(); } public interface MyRefInt { @Integrity public void mymethod1(); } @Service(MyService.class) @ManagedTransaction public class MyServiceImpl { @Confidentiality @Reference protected MyRefInt myRef; public void mymethod() {...} } the intropected componentType is: <componentType> <implementation.java class="MyServiceImpl" requires="managedTransaction"/> <service name="MyService" requires="managedTransaction"> <interface.java interface="MyService"/> </service> <reference name="myRef" requires="confidentiality"> <interface.java interface="MyRefInt"/> </reference> </componentType> Simon
[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]