Package

Source Code of ActivationLibrary$ExportHelper

/*
* 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.
*/
/**
*
*/

import com.sun.jini.jeri.internal.runtime.Util;
import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Naming;
import java.rmi.NoSuchObjectException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.MarshalledObject;
import java.rmi.activation.Activatable;
import java.rmi.activation.ActivationDesc;
import java.rmi.activation.ActivationException;
import java.rmi.activation.ActivationID;
import java.rmi.server.ExportException;
import java.rmi.server.RMIClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import net.jini.activation.ActivatableInvocationHandler;
import net.jini.activation.ActivationExporter;
import net.jini.activation.ActivationGroup;
import net.jini.core.constraint.RemoteMethodControl;
import net.jini.export.Exporter;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;
import net.jini.jrmp.JrmpExporter;
import net.jini.security.proxytrust.ProxyTrust;
import net.jini.security.proxytrust.TrustEquivalence;

/**
* Class of test utility/library methods related to Activatable
* objects.
*/
public class ActivationLibrary {
    /** time safeDestroy should wait before failing on shutdown rmid */
    final static int SAFE_WAIT_TIME = 60000;

    static void mesg(Object mesg) {
  System.err.println("ACTIVATION_LIBRARY: " + mesg.toString());
    }

    /**
     * Deactivate an activated Activatable
     */
    public static void deactivate(Remote remote, ActivationID id) {
  deactivate(remote, id, null);
    }

    /**
     * Deactivates an activated object.  If exporter is null, then
     * deactivate using pre 1.4-APIs; otherwise use the new 1.4
     * API.
     */
    public static void deactivate(Remote remote,
          ActivationID id,
          Exporter exporter)
    {
  int i = 0;
  do {
      i++;
      try {
    boolean success =
        ((exporter == null) ?
         Activatable.inactive(id) :
         ActivationGroup.inactive(id, exporter));
       
    if (success) {
        mesg("inactive successful");
        return;
    } else {
        Thread.sleep(1000);
    }
      } catch (InterruptedException e) {
    continue;
      } catch (Exception e) {
    e.printStackTrace();
    break;
      }
  } while (i < 5);
 
  mesg("giving up on deactivation after " + i + " attempts");
  mesg("unexporting object forcibly instead");

  forcedUnexport(remote, exporter);
    }

    /**
     * Forcibly unexports the object.
     */
    public static void forcedUnexport(Remote remote, Exporter exporter) {
 
  try {
      // forcibly unexport the object
      if (exporter == null) {
    Activatable.unexportObject(remote, true);
      } else {
    exporter.unexport(true);
      }
  } catch (NoSuchObjectException ex) {
  }
    }


    /**
     * Simple method call to see if rmid is running.
     *
     * This method intentionally avoids performing a lookup on the
     * activation system. 
     */
    public static boolean rmidRunning(int port) {
  int allowedNotReady = 10;
  int connectionRefusedExceptions = 0;

  for (int i = 0; i < 15 ; i++) {

      try {
    Thread.sleep(500);
    if (containsString(Naming.list("//:" + port ),
        "java.rmi.activation.ActivationSystem"))
                {
        return true;
    }

      } catch (java.rmi.ConnectException ce) {
    // ignore connect exceptions until we decide rmid is not up
    if ((connectionRefusedExceptions ++) >= allowedNotReady) {
        return false;
    }

      } catch (Exception e) {
    // print out other types of exceptions as an FYI.
    // test should not fail as rmid is likely to be in an
    // undetermined state at this point.

    mesg("caught an exception trying to" +
         " start rmid, last exception was: " +
         e.getMessage());
    e.printStackTrace();
      }
  }
  return false;
    }

    /**
     * Check to see if an arry of Strings contains a given string.
     */
    private static boolean
  containsString(String[] strings, String contained)
    {
  if (strings == null) {
      if (contained == null) {
    return true;
      }
      return false;
  }
 
  for (int i = 0 ; i < strings.length ; i ++ ) {
      if ((strings[i] != null) &&
    (strings[i].indexOf(contained) >= 0))
      {
    return true;
      }
  }
  return false;
    }

    /** cleanup after rmid */
    public static void rmidCleanup(RMID rmid) {
  if (rmid != null) {
      if (!ActivationLibrary.safeDestroy(rmid,
                 SAFE_WAIT_TIME))
      {
    TestLibrary.bomb("rmid not destroyed in: " +
         SAFE_WAIT_TIME +
         " milliseconds");
      }
  }
  RMID.removeLog();
    }

    /**
     * Invoke shutdown on rmid in a way that will not cause a test
     * to hang.
     *
     * @return whether or not shutdown completed succesfully in the
     *         timeAllowed
     */
    public static boolean safeDestroy(RMID rmid, long timeAllowed) {
  DestroyThread destroyThread = new DestroyThread(rmid);
  destroyThread.start();

  try {
      destroyThread.join(timeAllowed);
  } catch (InterruptedException ie) {
      Thread.currentThread().interrupt();
  }

  return destroyThread.shutdownSucceeded();
    }

    /**
     * Thread class to handle the destruction of rmid
     */
    static class DestroyThread extends Thread {
  RMID rmid = null;
  boolean succeeded = false;

  DestroyThread(RMID rmid) {
      this.rmid = rmid;
      this.setDaemon(true);
  }

  public void run() {
      if (ActivationLibrary.
    rmidRunning(TestLibrary.RMID_PORT))
            {
    rmid.destroy();

    synchronized (this) {
        // flag that the test was able to shutdown rmid
        succeeded = true;
    }
    mesg("finished destroying rmid");
      } else {
    mesg("tried to shutdown when rmid was not running");
      }
  }

  public synchronized boolean shutdownSucceeded() {
      return succeeded;
  }
    }


    public static Remote createProxy(ActivationID id, ActivationDesc desc)
    {
  try {
      Class cl = RMIClassLoader.loadClass(desc.getLocation(),
            desc.getClassName());
      Class[] remoteInterfaces = Util.getRemoteInterfaces(cl);
      InvocationHandler handler =
    new ActivatableInvocationHandler(id, null);
      return (Remote) newProxyInstance(null, remoteInterfaces, handler);
  } catch (Exception e) {
      throw (RuntimeException)
    new RuntimeException("proxy creation failed").initCause(e);
  }
    }

    public static Remote createSecureProxy(ActivationID id,
             ActivationDesc desc)
    {
  try {
      Class cl = RMIClassLoader.loadClass(desc.getLocation(),
            desc.getClassName());
      Class[] remoteInterfaces = Util.getRemoteInterfaces(cl);
      List list = new ArrayList(Arrays.asList(remoteInterfaces));
      if (list.remove(ProxyTrust.class)) {
    remoteInterfaces =
        (Class[]) list.toArray(new Class[list.size()]);
      }
      InvocationHandler handler =
    new ActivatableInvocationHandler(id, null);
      return (Remote) newProxyInstance(remoteInterfaces,
               new Class[]{
               RemoteMethodControl.class,
               TrustEquivalence.class},
               handler);
  } catch (Exception e) {
      throw (RuntimeException)
    new RuntimeException("proxy creation failed").initCause(e);
  }
    }

    /**
     * Returns a proxy that implements the concatenation of the specified
     * interfaces, containing the specified invocation handler.
     */
    public static Remote newProxyInstance(Class[] ifs1,
             Class[] ifs2,
             InvocationHandler ih)
    {
  Class[] ifs = combineInterfaces(ifs1, ifs2);
  return (Remote) Proxy.newProxyInstance(pickClassLoader(ifs), ifs, ih);
    }

    /**
     * Returns a concatenated array of the interfaces in i1 and i2.
     */
    public static Class[] combineInterfaces(Class[] i1, Class[] i2) {

  if (i1 == null) {
      return i2;
  } else if (i2 == null) {
      return i1;
  } else {
      Class[] interfaces = new Class[i1.length + i2.length];
      System.arraycopy(i1, 0, interfaces, 0, i1.length);
      System.arraycopy(i2, 0, interfaces, i1.length, i2.length);
      return interfaces;
  }
    }

    /**
     * Returns the preferred classloader to use for defining a proxy class
     * that implements all of the specified interfaces.
     */
    private static ClassLoader pickClassLoader(Class[] ifs) {
    outer:
  for (int i = ifs.length; --i >= 0; ) {
      ClassLoader l = ifs[i].getClassLoader();
      for (int j = ifs.length; --j >= 0; ) {
    if (!covers(l, ifs[j].getClassLoader())) {
        continue outer;
    }
      }
      return l;
  }
  throw new IllegalArgumentException(
              "no classloader covers all interfaces");
    }

    /**
     * Returns true if the first argument is either equal to, or is a
     * descendant of, the second argument.  Null is treated as the root of
     * the tree.
     */
    public static boolean covers(ClassLoader sub, ClassLoader sup) {
  if (sup == null) {
      return true;
  } else if (sub == null) {
      return false;
  }
  do {
      if (sub == sup) {
    return true;
      }
      sub = sub.getParent();
  } while (sub != null);
  return false;
    }

    public static Remote register(String exportType, ActivationDesc desc)
  throws ActivationException, RemoteException
    {
  if (exportType.equals("default")) {
      return Activatable.register(desc);
  } else {
      ActivationID id =
    ActivationGroup.getSystem().registerObject(desc);
      if (exportType.equals("basic")) {
    return createSecureProxy(id, desc);
      } else if (exportType.equals("jrmp")) {
    return createProxy(id, desc);
      } else {
    throw new ActivationException("unknown exportType");
      }
  }
    }
   
    public static class ExportHelper implements Runnable {

  private final String exportType;
  private final ActivationID id;
  private final Remote impl;
  private Remote stub;
  private Exporter exporter = null;
 
  public ExportHelper(MarshalledObject mobj,
          Remote impl,
          ActivationID id)
          throws ActivationException
  {
      try {
    this.exportType = (String) mobj.get();
      } catch (Exception e) {
    throw new ActivationException(
      "MarshalledObject.get failed", e);
      }
 
      this.impl = impl;
      this.id = id;
  }

  public ExportHelper(String exportType,
          Remote impl,
          ActivationID id)
          throws ActivationException
  {
      this.exportType = exportType;
      this.impl = impl;
      this.id = id;
  }
 
  public Remote export() throws RemoteException {
      if (exportType.equals("default")) {
    stub = Activatable.exportObject(impl, id, 0);
      } else {
    Exporter uexporter;
    if (exportType.equals("basic")) {
        uexporter = new
      BasicJeriExporter(TcpServerEndpoint.getInstance(0),
            new BasicILFactory(),
            true, true);
    } else if (exportType.equals("jrmp")) {
        uexporter = new JrmpExporter();
    } else {
        throw new ExportException("unknown exportType");
    }
    exporter = new ActivationExporter(id, uexporter);
    stub = exporter.export(impl);
      }
      System.err.println("stub = " + stub.toString());
      return stub;
  }

  public Remote getStub() {
      return stub;
  }

  public ActivationID getActivationID() {
      return id;
  }

  public void deactivate() {
      (new Thread(this, "ExportHelper")).start();
  }

  public void run() {
      ActivationLibrary.deactivate(impl, id, exporter);
  }
    }
}
TOP

Related Classes of ActivationLibrary$ExportHelper

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.