1. /*

  2.  * @(#)POAPolicyCombinationValidator.java	1.6 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.corba.se.internal.POA;

  8. 

  9. import org.omg.CORBA.*;

  10. import org.omg.CORBA.portable.*;

  11. import org.omg.PortableServer.*;

  12. import org.omg.PortableServer.POAPackage.*;

  13. import org.omg.PortableServer.ServantLocatorPackage.*;

  14. 

  15. import com.sun.corba.se.internal.core.*;

  16. import com.sun.corba.se.internal.corba.*;

  17. import com.sun.corba.se.internal.util.*;

  18. 

  19. import java.util.*;

  20. 

  21. // NOTE: Current implementation does not check for duplicates and 

  22. // repeated policy objects of the same type.

  23. 

  24. public final class POAPolicyCombinationValidator{

  25. 

  26.     // policy processing.

  27. 

  28.     //Always return _index <= -1 if there are no invalid policies in

  29.     //the scope of constraint resolution.

  30.     public static short checkForInvalidPolicyCombinations(Policy[] policies) {

  31.         short returnIndex  = -1; 

  32.         short currentIndex = -1;

  33.         //Validity for this orb implementation. See the POA spec on policies.

  34.         returnIndex  = checkValidityForThisORBImplementation(policies);

  35.         //Consistency of the combination of policies. See the POA spec on policies.

  36.         currentIndex = checkConsistency(policies);

  37.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  38.         //Missing administrative actions. See the POA spec on policies.

  39.         currentIndex = checkMissingAdministrativeActions(policies);

  40.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  41.         //Return the minimal non-negative index of the offending policy or -1;

  42.         //-1 indicates no policy violations detected by current algorithm.

  43.         return returnIndex;

  44.     }

  45. 

  46.     private static short checkValidityForThisORBImplementation(Policy[] policies){

  47.         return -1;

  48.     }

  49. 

  50.     private static short checkConsistency(Policy[] policies){

  51.         short returnIndex  = -1; 

  52.         short currentIndex = -1;

  53.         //uaomo_req_r == USE_ACTIVE_OBJECT_MAP_ONLY requires RETAIN

  54.         returnIndex  = uaomo_req_r(policies);

  55.         //nR_req_uds_o_usm == NON_RETAIN requires USE_DEFAULT_SERVANT OR USE_SERVANT_MANAGER

  56.         currentIndex = nR_req_uds_o_usm(policies);

  57.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  58.         //ia_req_si_a_r == IMPLICIT_ACTIVATION requires SYSTEM_ID and RETAIN

  59.         currentIndex = ia_req_si_a_r(policies);

  60.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  61.         //life_span_excluded_middle == ! (PERSISTENT && TRANSIENT)

  62.         currentIndex = life_span_excluded_middle(policies);

  63.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  64.         //servant_retention_excluded_middle == ! (RETAIN && NON_RETAIN)

  65.         currentIndex = servant_retention_excluded_middle(policies);

  66.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  67.         //id_uniqueness_excluded_middle == ! (UNIQUE_ID && MULTIPLE_ID)

  68.         currentIndex = id_uniqueness_excluded_middle(policies);

  69.         returnIndex  = findNonNegativeMinimumIfItExists(currentIndex,returnIndex);

  70.         // can add other consistency checks with the same procedure for index management.

  71.         return returnIndex;

  72.     }

  73. 

  74.     // Returns -1 if non-negative minimum does not exist.

  75.     private static short findNonNegativeMinimumIfItExists(short currentIndex, short returnIndex){

  76.         //If any of them is -1, set it to the other.

  77.         if ( returnIndex  == -1 ) returnIndex  = currentIndex;

  78.         if ( currentIndex == -1 ) currentIndex = returnIndex ;

  79.         //By now, if any of them is not -1 and the other is, the other is set to it.

  80.         //If both are -1, -1 will be returned in the last statement.

  81.         if ( currentIndex != -1 || returnIndex != -1 ) returnIndex = (short)Math.min(currentIndex,returnIndex);

  82.         return returnIndex;

  83.     }

  84. 

  85.     private static short checkMissingAdministrativeActions(Policy[] policies){

  86.         return -1;

  87.     }

  88. 

  89.     //uaomo_req_r == USE_ACTIVE_OBJECT_MAP_ONLY requires RETAIN

  90.     private static short uaomo_req_r(Policy[] policies){

  91.         RequestProcessingPolicy rpp = null; short rpp_index = -1;

  92.         ServantRetentionPolicy  srp = null; short srp_index = -1;

  93.         for(short i=0; i<policies.length; i++){

  94.             if ( policies[i] instanceof RequestProcessingPolicy ){

  95.                 rpp=(RequestProcessingPolicy)policies[i];

  96.                 rpp_index=i;

  97.             }

  98.             if ( policies[i] instanceof ServantRetentionPolicy ) {

  99.                 srp=(ServantRetentionPolicy)policies[i];

  100.                 srp_index=i;

  101.             }

  102.         }

  103.         if (rpp!=null && rpp.value()==

  104.             org.omg.PortableServer.RequestProcessingPolicyValue.USE_ACTIVE_OBJECT_MAP_ONLY){

  105.             if (srp_index==-1) /* Default is Retain so we're OK*/ 

  106.                 return -1;

  107.             else {

  108.                 if(srp!=null && srp.value()

  109.                    ==org.omg.PortableServer.ServantRetentionPolicyValue.NON_RETAIN)

  110.                     return (short)Math.min(rpp_index,srp_index);

  111.                 else return -1;

  112.             }

  113.         } else return -1;

  114.     }

  115. 

  116.     //nR_req_uds_o_usm == NON_RETAIN requires USE_DEFAULT_SERVANT OR USE_SERVANT_MANAGER

  117.     private static short nR_req_uds_o_usm(Policy[] policies){

  118.         return -1;

  119.     }

  120. 

  121.     //ia_req_si_a_r == IMPLICIT_ACTIVATION requires SYSTEM_ID and RETAIN

  122.     //When combination is violated, returned index is the minimum index

  123.     //of *the* violating combination.

  124.     private static short ia_req_si_a_r(Policy[] policies){

  125.         short returnIndex = -1;

  126.         ImplicitActivationPolicy iap = null;   short iap_index = -1;

  127.         IdAssignmentPolicy       idp = null;   short idp_index = -1;

  128.         ServantRetentionPolicy   srp = null;   short srp_index = -1;

  129.         //Collect policies and indeces.

  130.         for(short i=0; i<policies.length; i++){

  131.             if ( policies[i] instanceof ImplicitActivationPolicy ){

  132.                 iap       = (ImplicitActivationPolicy)policies[i];

  133.                 iap_index = i;

  134.             }

  135.             if ( policies[i] instanceof IdAssignmentPolicy ) {

  136.                 idp       = (IdAssignmentPolicy)policies[i];

  137.                 idp_index = i;

  138.             }

  139.             if ( policies[i] instanceof ServantRetentionPolicy ) {

  140.                 srp       = (ServantRetentionPolicy)policies[i];

  141.                 srp_index = i;

  142.             }

  143.         }

  144.         if (iap == null) return -1; //The rule is for IMPLICIT_ACTIVATION which is not the default.

  145.         else { //ImplicitActivationPolicy is set.

  146.             if (iap.value()!=org.omg.PortableServer.ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION) {

  147.                 return -1; // Default is NO_IMPLICIT_ACTIVATION, so we're OK.

  148.             }

  149.             else { // IMPLICIT_ACTIVATION has been set.

  150.                 if( srp == null ) { //Default: RETAIN

  151.                     srp_index = -1;

  152.                     if ( idp == null ) return -1; // Defaults are RETAIN and SYSTEM_ID. So we're OK.

  153.                     else { //IdAssignmentPolicy is set by user.

  154.                         //if IdAssignmentPolicy violates the rule, return minimal index of the set.

  155.                         if ( idp.value()!=org.omg.PortableServer.IdAssignmentPolicyValue.SYSTEM_ID)

  156.                             return findNonNegativeMinimumIfItExists(idp_index,iap_index);

  157.                         else //IdAssignmentPolicy does not violate the rule; 

  158.                             return -1;

  159.                     }

  160.                 }

  161.                 else { // ServantRetentionPolicy is set by user.

  162.                     //If ServantRetentionPolicy violates the rule, return minimal index of the set.

  163.                     if(srp.value()!=org.omg.PortableServer.ServantRetentionPolicyValue.RETAIN){

  164.                         if ( idp == null) //Default: SYSTEM_ID

  165.                             return findNonNegativeMinimumIfItExists(srp_index , iap_index);

  166.                         else { //IdAssignmentPolicy is set by the user.

  167.                             if (idp.value()!=org.omg.PortableServer.IdAssignmentPolicyValue.SYSTEM_ID)

  168.                                 //All policies are set wrong !!!

  169.                                 return findNonNegativeMinimumIfItExists

  170.                                     (srp_index , findNonNegativeMinimumIfItExists(iap_index,idp_index));

  171.                             else //IdAssignmentPolicy does not violate the rule. 

  172.                                 return findNonNegativeMinimumIfItExists(srp_index , iap_index);

  173.                         }

  174.                     }

  175.                     else{ //The user's setting of ServantRetentionPolicy does not violate the rule

  176.                         if ( idp == null) //Default: SYSTEM_ID

  177.                             return -1 ;

  178.                         else { //IdAssignmentPolicy is set by the user.

  179.                             //If IdAssignmentPolicy violates the rule return the appropriate index.

  180.                             if (idp.value()!=org.omg.PortableServer.IdAssignmentPolicyValue.SYSTEM_ID)

  181.                                 return findNonNegativeMinimumIfItExists(iap_index,idp_index);

  182.                             else //IdAssignmentPolicy does not violate the rule. 

  183.                                 return -1;

  184.                         }

  185.                     }

  186.                 }

  187.             }

  188.             //Some index will be returned by one of the clauses above.

  189.         } //ImplicitAssignmentPolicy set to IMPLICIT_ACTIVATION

  190.     }

  191. 

  192.     //life_span_excluded_middle == ! (PERSISTENT && TRANSIENT)

  193.     private static short life_span_excluded_middle(Policy[] policies){

  194.         LifespanPolicy lp1 = null; short lp1_index = -1;

  195.         LifespanPolicy lp2 = null; /* short lp2_index = -1; */

  196.         for(short i=0; i<policies.length; i++){

  197.             if ( policies[i] instanceof LifespanPolicy ){

  198.                 if(lp1 == null){

  199.                     lp1=(LifespanPolicy)policies[i];

  200.                     lp1_index=i;

  201.                 } else {

  202.                     lp2=(LifespanPolicy)policies[i];

  203.                     /* lp2_index=i; */

  204.                     // LifespanPolicy can be either but not both 

  205.                     // of the two possible values

  206.                     if ( lp2.value() != lp1.value() ) return lp1_index;

  207.                     else return -1;

  208.                 }

  209.             }

  210.         }

  211.         return -1;

  212.     }

  213. 

  214.     //servant_retention_excluded_middle == ! (RETAIN && NON_RETAIN)

  215.     private static short servant_retention_excluded_middle(Policy[] policies){

  216.         ServantRetentionPolicy rp1 = null; short rp1_index = -1;

  217.         ServantRetentionPolicy rp2 = null; /* short rp2_index = -1; */

  218.         for(short i=0; i<policies.length; i++){

  219.             if ( policies[i] instanceof ServantRetentionPolicy ){

  220.                 if(rp1 == null){

  221.                     rp1=(ServantRetentionPolicy)policies[i];

  222.                     rp1_index=i;

  223.                 } else {

  224.                     rp2=(ServantRetentionPolicy)policies[i];

  225.                     /* rp2_index=i; */

  226.                     // ServantRetentionPolicy can be either but not both 

  227.                     // of the two possible values

  228.                     if ( rp2.value() != rp1.value() ) return rp1_index;

  229.                     else return -1;

  230.                 }

  231.             }

  232.         }

  233.         return -1;

  234.     }

  235. 

  236.     //id_uniqueness_excluded_middle == ! (UNIQUE_ID && MULTIPLE_ID)

  237.     private static short id_uniqueness_excluded_middle(Policy[] policies){

  238.         IdUniquenessPolicy id1 = null; short id1_index = -1;

  239.         IdUniquenessPolicy id2 = null; /* short id2_index = -1; */

  240.         for(short i=0; i<policies.length; i++){

  241.             if ( policies[i] instanceof IdUniquenessPolicy ){

  242.                 if(id1 == null){

  243.                     id1=(IdUniquenessPolicy)policies[i];

  244.                     id1_index=i;

  245.                 } else {

  246.                     id2=(IdUniquenessPolicy)policies[i];

  247.                     /* id2_index=i; */

  248.                     // IdUniquenessPolicy can be either but not both 

  249.                     // of the two possible values

  250.                     if ( id2.value() != id1.value() ) return id1_index;

  251.                     else return -1;

  252.                 }

  253.             }

  254.         }

  255.         return -1;

  256.     }

  257. 

  258. }