/// <summary> /// Destroys the current group. /// </summary> private static void DestroyGroup() { lock (typeof(ActivationGroup)) { CurrGroup = null; CurrGroupID = null; // NOTE: don't set currSystem to null since it may be needed } }
/// <summary> /// Compares two group identifiers for content equality. /// Returns true if both of the following conditions are true: /// 1) the unique identifiers are equivalent (by content), and /// 2) the activation system specified in each /// refers to the same remote object. /// </summary> /// <param name="obj"> the Object to compare with </param> /// <returns> true if these Objects are equal; false otherwise. </returns> /// <seealso cref= java.util.Hashtable /// @since 1.2 </seealso> public override bool Equals(Object obj) { if (this == obj) { return(true); } else if (obj is ActivationGroupID) { ActivationGroupID id = (ActivationGroupID)obj; return(Uid.Equals(id.Uid) && System_Renamed.Equals(id.System_Renamed)); } else { return(false); } }
/// <summary> /// Create and set the activation group for the current VM. The /// activation group can only be set if it is not currently set. /// An activation group is set using the <code>createGroup</code> /// method when the <code>Activator</code> initiates the /// re-creation of an activation group in order to carry out /// incoming <code>activate</code> requests. A group must first be /// registered with the <code>ActivationSystem</code> before it can /// be created via this method. /// /// <para>The group class specified by the /// <code>ActivationGroupDesc</code> must be a concrete subclass of /// <code>ActivationGroup</code> and have a public constructor that /// takes two arguments: the <code>ActivationGroupID</code> for the /// group and the <code>MarshalledObject</code> containing the /// group's initialization data (obtained from the /// <code>ActivationGroupDesc</code>. /// /// </para> /// <para>If the group class name specified in the /// <code>ActivationGroupDesc</code> is <code>null</code>, then /// this method will behave as if the group descriptor contained /// the name of the default activation group implementation class. /// /// </para> /// <para>Note that if your application creates its own custom /// activation group, a security manager must be set for that /// group. Otherwise objects cannot be activated in the group. /// <seealso cref="SecurityManager"/> is set by default. /// /// </para> /// <para>If a security manager is already set in the group VM, this /// method first calls the security manager's /// <code>checkSetFactory</code> method. This could result in a /// <code>SecurityException</code>. If your application needs to /// set a different security manager, you must ensure that the /// policy file specified by the group's /// <code>ActivationGroupDesc</code> grants the group the necessary /// permissions to set a new security manager. (Note: This will be /// necessary if your group downloads and sets a security manager). /// /// </para> /// <para>After the group is created, the /// <code>ActivationSystem</code> is informed that the group is /// active by calling the <code>activeGroup</code> method which /// returns the <code>ActivationMonitor</code> for the group. The /// application need not call <code>activeGroup</code> /// independently since it is taken care of by this method. /// /// </para> /// <para>Once a group is created, subsequent calls to the /// <code>currentGroupID</code> method will return the identifier /// for this group until the group becomes inactive. /// /// </para> /// </summary> /// <param name="id"> the activation group's identifier </param> /// <param name="desc"> the activation group's descriptor </param> /// <param name="incarnation"> the group's incarnation number (zero on group's /// initial creation) </param> /// <returns> the activation group for the VM </returns> /// <exception cref="ActivationException"> if group already exists or if error /// occurs during group creation </exception> /// <exception cref="SecurityException"> if permission to create group is denied. /// (Note: The default implementation of the security manager /// <code>checkSetFactory</code> /// method requires the RuntimePermission "setFactory") </exception> /// <exception cref="UnsupportedOperationException"> if and only if activation is /// not supported by this implementation </exception> /// <seealso cref= SecurityManager#checkSetFactory /// @since 1.2 </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static synchronized ActivationGroup createGroup(ActivationGroupID id, final ActivationGroupDesc desc, long incarnation) throws ActivationException //JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET: public static ActivationGroup CreateGroup(ActivationGroupID id, ActivationGroupDesc desc, long incarnation) { lock (typeof(ActivationGroup)) { SecurityManager security = System.SecurityManager; if (security != null) { security.CheckSetFactory(); } if (CurrGroup != null) { throw new ActivationException("group already exists"); } if (CanCreate == false) { throw new ActivationException("group deactivated and " + "cannot be recreated"); } try { // load group's class String groupClassName = desc.ClassName; Class cl; Class defaultGroupClass = typeof(sun.rmi.server.ActivationGroupImpl); if (groupClassName == null || groupClassName.Equals(defaultGroupClass.Name)) // see 4252236 { cl = defaultGroupClass; } else { Class cl0; try { cl0 = RMIClassLoader.LoadClass(desc.Location, groupClassName); } catch (Exception ex) { throw new ActivationException("Could not load group implementation class", ex); } if (cl0.IsSubclassOf(typeof(ActivationGroup))) { cl = cl0.AsSubclass(typeof(ActivationGroup)); } else { throw new ActivationException("group not correct class: " + cl0.Name); } } // create group //JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET: //ORIGINAL LINE: Constructor<? extends ActivationGroup> constructor = cl.getConstructor(ActivationGroupID.class, java.rmi.MarshalledObject.class); Constructor <?> constructor = cl.getConstructor(typeof(ActivationGroupID), typeof(MarshalledObject)); ActivationGroup newGroup = constructor.newInstance(id, desc.Data); CurrSystem = id.System; newGroup.Incarnation = incarnation; newGroup.Monitor_Renamed = CurrSystem.ActiveGroup(id, newGroup, incarnation); CurrGroup = newGroup; CurrGroupID = id; CanCreate = false; } catch (InvocationTargetException e) { e.TargetException.printStackTrace(); throw new ActivationException("exception in group constructor", e.TargetException); } catch (ActivationException e) { throw e; } catch (Exception e) { throw new ActivationException("exception creating group", e); } return(CurrGroup); } }
/// <summary> /// Constructs an activation group with the given activation group /// identifier. The group is exported as a /// <code>java.rmi.server.UnicastRemoteObject</code>. /// </summary> /// <param name="groupID"> the group's identifier </param> /// <exception cref="RemoteException"> if this group could not be exported </exception> /// <exception cref="UnsupportedOperationException"> if and only if activation is /// not supported by this implementation /// @since 1.2 </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: protected ActivationGroup(ActivationGroupID groupID) throws java.rmi.RemoteException protected internal ActivationGroup(ActivationGroupID groupID) : base() { // call super constructor to export the object this.GroupID = groupID; }