| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.yoko.orb.OB; |
| |
| import static org.apache.yoko.orb.OB.MinorCodes.MinorDestroyWouldBlock; |
| import static org.apache.yoko.orb.OB.MinorCodes.MinorORBDestroyed; |
| import static org.apache.yoko.orb.OB.MinorCodes.MinorShutdownCalled; |
| import static org.apache.yoko.orb.OB.MinorCodes.describeBadInvOrder; |
| import static org.apache.yoko.orb.OB.MinorCodes.describeInitialize; |
| import static org.omg.CORBA.CompletionStatus.COMPLETED_NO; |
| |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Phaser; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| import java.util.concurrent.locks.ReadWriteLock; |
| |
| import org.apache.yoko.orb.OBPortableServer.POAManagerFactory_impl; |
| import org.apache.yoko.orb.OBPortableServer.POA_impl; |
| import org.apache.yoko.orb.PortableServer.Current_impl; |
| import org.omg.CORBA.BAD_INV_ORDER; |
| import org.omg.CORBA.INITIALIZE; |
| import org.omg.CORBA.ORBPackage.InvalidName; |
| import org.omg.PortableServer.POA; |
| import org.omg.PortableServer.CurrentPackage.NoContext; |
| |
| public final class ORBControl { |
| // |
| // The ORB instance |
| // |
| ORBInstance orbInstance_; |
| |
| // |
| // The ORBControl state |
| // |
| private enum State { NOT_RUNNING, RUNNING, SERVER_SHUTDOWN, CLIENT_SHUTDOWN, DESTROYED }; |
| private volatile State state; // State of the ORB |
| |
| // |
| // Has shutdown been called? |
| // |
| private final CountDownLatch shutdown = new CountDownLatch(1); |
| |
| // |
| // The Root POA |
| // |
| private POA rootPOA_; // The Root POA |
| |
| // |
| // The thread id of the main thread (that is the first thread that |
| // calls run, perform_work or work_pending) |
| // |
| private volatile Thread mainThread_; |
| |
| private long shutdownTimeout_ = 2;//seconds |
| |
| |
| // ---------------------------------------------------------------------- |
| // ORBControl private and protected member implementations |
| // ---------------------------------------------------------------------- |
| |
| // |
| // Complete shutdown of the ORB, if necessary |
| // |
| private synchronized void completeServerShutdown() { |
| // |
| // If the shutdown_ is false, or the server side has already |
| // shutdown then do nothing |
| // |
| if (shutdown.getCount() != 0 || state == State.SERVER_SHUTDOWN) |
| return; |
| |
| Assert._OB_assert(state != State.CLIENT_SHUTDOWN && state != State.DESTROYED); |
| |
| // |
| // If run was called then only the main thread may complete the |
| // shutdown |
| // |
| Assert._OB_assert(state == State.NOT_RUNNING || mainThread_ == Thread.currentThread()); |
| |
| // |
| // Get the POAManagerFactory implementation |
| // |
| POAManagerFactory_impl factory = (POAManagerFactory_impl) orbInstance_.getPOAManagerFactory(); |
| |
| // |
| // Deactivate all of the POAManagers |
| // |
| factory._OB_deactivate(); |
| |
| // |
| // Wait for all the threads in the server worker group to |
| // terminate |
| // |
| waitForServerThreads(); |
| notifyAll(); |
| } |
| |
| private void waitForServerThreads() { |
| shutdownExecutor(orbInstance_.getServerPhaser(), orbInstance_.getServerExecutor()); |
| |
| // |
| // Get the DispatchStrategyFactory implementation and |
| // destroy it. It must be destroyed here so that the |
| // thread pools get destroyed before OCI::Current_impl |
| // gets destroyed by the destruction of the Root |
| // POA. Otherwise, thread specific data for the thread |
| // pool threads will not get released. |
| // |
| DispatchStrategyFactory dsFactory = orbInstance_.getDispatchStrategyFactory(); |
| |
| DispatchStrategyFactory_impl dsFactoryImpl = (DispatchStrategyFactory_impl) dsFactory; |
| |
| dsFactoryImpl._OB_destroy(); |
| |
| // |
| // Mark the server side state as shutdown and notify any |
| // waiting threads |
| // |
| state = State.SERVER_SHUTDOWN; |
| |
| // |
| // Destroy the root POA |
| // |
| if (rootPOA_ != null) { |
| rootPOA_.destroy(true, true); |
| rootPOA_ = null; |
| } |
| } |
| |
| // |
| // Validate the state |
| // |
| private synchronized void validateState() { |
| // |
| // The ORB destroys this object, so it's an initialization |
| // error if the this operation is called after ORB destruction |
| // |
| if (state == State.DESTROYED) |
| throw new org.omg.CORBA.INITIALIZE( |
| org.apache.yoko.orb.OB.MinorCodes.describeInitialize(org.apache.yoko.orb.OB.MinorCodes.MinorORBDestroyed), |
| org.apache.yoko.orb.OB.MinorCodes.MinorORBDestroyed, org.omg.CORBA.CompletionStatus.COMPLETED_NO); |
| |
| if (state == State.SERVER_SHUTDOWN || state == State.CLIENT_SHUTDOWN) |
| throw new org.omg.CORBA.BAD_INV_ORDER( |
| org.apache.yoko.orb.OB.MinorCodes.describeBadInvOrder(org.apache.yoko.orb.OB.MinorCodes.MinorShutdownCalled), |
| org.apache.yoko.orb.OB.MinorCodes.MinorShutdownCalled, org.omg.CORBA.CompletionStatus.COMPLETED_NO); |
| |
| if (state == State.NOT_RUNNING) { |
| // |
| // Remember the main thread id |
| // |
| mainThread_ = Thread.currentThread(); |
| |
| // |
| // Set the state to State.RUNNING |
| // |
| state = State.RUNNING; |
| } |
| } |
| |
| private synchronized void blockServerShutdownComplete() { |
| // |
| // Wait for the server side to shutdown. Note that the client |
| // side shutting down or the state being destroyed also |
| // implies that the server side has shutdown |
| // |
| while (state == State.RUNNING) { |
| try { |
| wait(); |
| } catch (InterruptedException ex) { |
| } |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| // ORBControl public member implementations |
| // ---------------------------------------------------------------------- |
| |
| public ORBControl() { |
| state = State.NOT_RUNNING; |
| } |
| |
| // |
| // Destroy the ORBControl |
| // |
| public synchronized void destroy() { |
| // |
| // destroy() may not be called unless the client side has been |
| // shutdown |
| // |
| Assert._OB_assert(state == State.CLIENT_SHUTDOWN); |
| state = State.DESTROYED; |
| |
| // |
| // Set the ORBInstance object to nil |
| // |
| orbInstance_ = null; |
| } |
| |
| // |
| // Set the ORBInstance object |
| // |
| public void setORBInstance(ORBInstance instance) { |
| orbInstance_ = instance; |
| } |
| |
| // |
| // Determine if there if the ORB needs the main thread to perform |
| // some work |
| // |
| public boolean workPending() { |
| validateState(); |
| |
| // |
| // If this is not the main thread then do nothing |
| // |
| if (mainThread_ != Thread.currentThread()) |
| return false; |
| |
| // |
| // Validate state will throw an exception if state is |
| // ServerShutdown, ClientShutdown or Destroyed. Therefore if |
| // shutdown_ is true, then a server side shutdown is pending. |
| // |
| return (shutdown.getCount() == 0); |
| } |
| |
| // |
| // Perform one unit of work |
| // |
| public void performWork() { |
| validateState(); |
| |
| // |
| // If this is not the main thread then do nothing |
| // |
| if (mainThread_ != Thread.currentThread()) |
| return; |
| |
| completeServerShutdown(); |
| } |
| |
| // |
| // Run the ORB event loop |
| // |
| public void run() { |
| validateState(); |
| |
| // |
| // If this is not the main thread then block until the ORB is |
| // shutdown |
| // |
| if (mainThread_ != Thread.currentThread()) { |
| blockServerShutdownComplete(); |
| return; |
| } |
| |
| // |
| // Validate state will throw an exception if state is |
| // ServerShutdown, ClientShutdown or Destroyed. Therefore if |
| // shutdown_ is true, then a server side shutdown is pending |
| // so complete it now. |
| // |
| if (shutdown.getCount() == 0) { |
| completeServerShutdown(); |
| return; |
| } |
| |
| // |
| // Block until the ORB server side has shutdown. Note that the |
| // client side shutting down or the state being destroyed also |
| // implies that the server side has shutdown |
| // |
| do { |
| try { |
| shutdown.await(); |
| } catch (InterruptedException ignored) { |
| } |
| |
| // |
| // After this call state is either ShutdownClient, or |
| // Running |
| // |
| completeServerShutdown(); |
| } while (state == State.RUNNING); |
| } |
| |
| // |
| // Shutdown the server side of the ORB |
| // |
| // ASYNC SAFE if waitForCompletion == false |
| // |
| public void shutdownServer(boolean waitForCompletion) { |
| // |
| // The ORB destroys this object, so it's an initialization error |
| // if the this operation is called after ORB destruction |
| // |
| if (state == State.DESTROYED) |
| throw new INITIALIZE(describeInitialize(MinorORBDestroyed), MinorORBDestroyed, COMPLETED_NO); |
| |
| if (state == State.SERVER_SHUTDOWN || state == State.CLIENT_SHUTDOWN) |
| throw new BAD_INV_ORDER(describeBadInvOrder(MinorShutdownCalled), MinorShutdownCalled, COMPLETED_NO); |
| |
| // |
| // If waitForCompletion is true then find out whether we're inside |
| // a method invocation -- if so throw a BAD_INV_ORDER exception |
| // |
| if (waitForCompletion) { |
| boolean inInvocation = false; |
| try { |
| InitialServiceManager initialServiceManager = orbInstance_.getInitialServiceManager(); |
| org.omg.CORBA.Object o = initialServiceManager.resolveInitialReferences("POACurrent"); |
| Current_impl current = (Current_impl) o; |
| inInvocation = current._OB_inUpcall(); |
| if (inInvocation) { |
| // |
| // Check whether or not the request is dispatched in this |
| // POAManager's ORB or another ORB. |
| // |
| try { |
| POA_impl p = (POA_impl) current.get_POA(); |
| inInvocation = (p._OB_ORBInstance() == orbInstance_); |
| } catch (NoContext ex) { |
| } |
| } |
| } catch (ClassCastException ex) { |
| } catch (InvalidName ex) { |
| } |
| |
| if (inInvocation) |
| throw new BAD_INV_ORDER(describeBadInvOrder(MinorDestroyWouldBlock), MinorDestroyWouldBlock, COMPLETED_NO); |
| } |
| |
| // |
| // Unblock run(). This should be done immediately before |
| // the return since this can cause the main loop to wake and |
| // complete the shutdown (thus, for instance, destroying the |
| // POAManagerFactory). |
| // |
| shutdown.countDown(); |
| |
| // |
| // waitForCompletion false? We're done. |
| // |
| if (!waitForCompletion) |
| return; |
| |
| // |
| // If run was called and this is not the main thread and |
| // waitForCompletion is true then wait for the shutdown to |
| // complete. |
| // |
| if (state == State.RUNNING && mainThread_ != Thread.currentThread()) { |
| blockServerShutdownComplete(); |
| return; |
| } |
| |
| // |
| // This is the main thread -- complete the shutdown process |
| // |
| completeServerShutdown(); |
| } |
| |
| // |
| // Shutdown the server (if necessary) & client side of the ORB |
| // |
| public synchronized void shutdownServerClient() { |
| // |
| // The ORB destroys this object, so it's an initialization |
| // error if the this operation is called after ORB destruction |
| // |
| if (state == State.DESTROYED) |
| throw new org.omg.CORBA.INITIALIZE( |
| org.apache.yoko.orb.OB.MinorCodes.describeInitialize(org.apache.yoko.orb.OB.MinorCodes.MinorORBDestroyed), |
| org.apache.yoko.orb.OB.MinorCodes.MinorORBDestroyed, org.omg.CORBA.CompletionStatus.COMPLETED_NO); |
| |
| // |
| // If the ORB client side is already shutdown, then we're done |
| // |
| if (state == State.CLIENT_SHUTDOWN) |
| return; |
| |
| if (orbInstance_ != null) { |
| // |
| // First shutdown the server side, if necessary |
| // |
| if (state != State.SERVER_SHUTDOWN) |
| shutdownServer(true); |
| |
| // |
| // The server shutdown must have completed |
| // |
| Assert._OB_assert(state == State.SERVER_SHUTDOWN); |
| |
| // |
| // Shutdown the client side. Continue to dispatch events until all |
| // client type event handlers have unregistered. |
| // |
| ClientManager clientManager = orbInstance_.getClientManager(); |
| clientManager.destroy(); |
| |
| // |
| // Wait for all the threads in the client worker group to |
| // terminate |
| // |
| shutdownExecutor(orbInstance_.getClientPhaser(), orbInstance_.getClientExecutor()); |
| } |
| |
| // |
| // Mark the ORB's client side as shutdown and notify any |
| // waiters |
| // |
| state = State.CLIENT_SHUTDOWN; |
| notifyAll(); |
| } |
| |
| private void shutdownExecutor(Phaser phaser, ExecutorService executor) { |
| int phase = phaser.arrive();//release the system's "lock" |
| //phaser advances after all GIOPConnectionThreaded have shut down (gracefully or abort) |
| try { |
| phaser.awaitAdvanceInterruptibly(phase, shutdownTimeout_, TimeUnit.SECONDS); |
| } catch (InterruptedException e1) { |
| Thread.currentThread().interrupt(); |
| } catch (TimeoutException e) { |
| } finally { |
| phaser.forceTermination(); |
| } |
| executor.shutdownNow(); |
| } |
| |
| // |
| // Initialize the Root POA |
| // |
| public void initializeRootPOA(org.omg.CORBA.ORB orb) { |
| String serverId = orbInstance_.getServerId(); |
| |
| // |
| // If there is no server id then set to "_RootPOA" |
| // |
| if (serverId.length() == 0) |
| serverId = "_RootPOA"; |
| |
| // |
| // Get the initial service manager |
| // |
| InitialServiceManager ism = orbInstance_.getInitialServiceManager(); |
| |
| // |
| // Create the Root POAManager |
| // |
| org.apache.yoko.orb.OBPortableServer.POAManagerFactory factory = null; |
| try { |
| factory = org.apache.yoko.orb.OBPortableServer.POAManagerFactoryHelper.narrow(ism.resolveInitialReferences("POAManagerFactory")); |
| } catch (org.omg.CORBA.ORBPackage.InvalidName ex) { |
| Assert._OB_assert(ex); |
| } |
| |
| // |
| // First attempt to locate the root POAManager |
| // |
| org.apache.yoko.orb.OBPortableServer.POAManager manager = null; |
| |
| org.omg.PortableServer.POAManager[] managers = factory.list(); |
| for (int i = 0; i < managers.length; i++) { |
| if (managers[i].get_id().equals("RootPOAManager")) { |
| manager = (org.apache.yoko.orb.OBPortableServer.POAManager) managers[i]; |
| break; |
| } |
| } |
| |
| // |
| // If the root POAManager doesn't exist then create it |
| // |
| if (manager == null) { |
| try { |
| org.omg.CORBA.Policy[] emptyPl = new org.omg.CORBA.Policy[0]; |
| manager = (org.apache.yoko.orb.OBPortableServer.POAManager) (factory.create_POAManager("RootPOAManager", emptyPl)); |
| } catch (org.omg.PortableServer.POAManagerFactoryPackage.ManagerAlreadyExists ex) { |
| Assert._OB_assert(ex); |
| } |
| // catch(org.apache.yoko.orb.OCI.InvalidParam ex) |
| // { |
| // Logger logger = orbInstance_.getLogger(); |
| // String err = "invalid configuration parameter " + |
| // "for RootPOAManager: " + ex.reason; |
| // logger.error(err); |
| // throw new org.omg.CORBA.INITIALIZE(err); |
| // } |
| catch (org.omg.CORBA.PolicyError ex) { |
| // TODO : Is this correct? |
| Assert._OB_assert(ex); |
| } |
| } |
| |
| // |
| // Create the Root POA |
| // |
| org.apache.yoko.orb.OBPortableServer.POA_impl root = new org.apache.yoko.orb.OBPortableServer.POA_impl(orb, orbInstance_, serverId, manager); |
| root._OB_addPolicyFactory(); |
| rootPOA_ = root; |
| |
| try { |
| ism.addInitialReference("RootPOA", root, true); |
| } catch (org.omg.CORBA.ORBPackage.InvalidName ex) { |
| Assert._OB_assert(ex); |
| } |
| |
| // |
| // Ask the POAManagerFactory to initialize this servers connection |
| // to the IMR |
| // |
| // TODO-B3: Is there some other point that can be used to do this? |
| // |
| org.apache.yoko.orb.OBPortableServer.POAManagerFactory_impl factoryImpl = (org.apache.yoko.orb.OBPortableServer.POAManagerFactory_impl) factory; |
| factoryImpl._OB_initializeIMR(root, this); |
| } |
| } |
