JAVA-98: Examples for latest proposal

[Simon Nash <oasis@cjnash.com>]

As requested, here are some examples showing how the various points
of this proposal would work.  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) 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

Simon Nash wrote:
> Here is a simplified version of the proposal with the following changes
> from the previous proposal:
>  1. Disallow intents on implementation methods.
>  2. Allow implementation intents on interface methods and interfaces.
> 
> 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 a Java class or Java interface used as
>    an SCA service interface, a method of a Java class or Java interface
>    used as an SCA service interface, a Java class used as an
>    SCA service implementation, a Java reference, a Java interface for
>    a reference, or a method of a Java interface for a reference.  It is
>    an error to apply an intent to a method of a Java class not used as
>    an SCA service interface.
> 
> 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 methods of a Java implementation
>    class or Java interface used to define an SCA service interface,
>    and to the methods of the Java interface for a reference.
> 
> 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.
> 
>   Simon
> 
> 
> ---------------------------------------------------------------------
> To unsubscribe from this mail list, you must leave the OASIS TC that
> generates this mail.  Follow this link to all your TCs in OASIS at:
> https://www.oasis-open.org/apps/org/workgroup/portal/my_workgroups.php
> 
>