RaiseException.java

  1. /***** BEGIN LICENSE BLOCK *****
  2.  * Version: EPL 1.0/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Eclipse Public
  5.  * License Version 1.0 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.eclipse.org/legal/epl-v10.html
  8.  *
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  *
  14.  * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
  15.  * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  16.  * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
  17.  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  18.  * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
  19.  * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com>
  20.  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  21.  * Copyright (C) 2005 Charles O Nutter <headius@headius.com>
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  25.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the EPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the EPL, the GPL or the LGPL.
  34.  ***** END LICENSE BLOCK *****/
  35. package org.jruby.exceptions;

  37. import java.io.PrintWriter;
  38. import java.io.StringWriter;

  40. import java.lang.reflect.Member;
  41. import org.jruby.NativeException;
  42. import org.jruby.Ruby;
  43. import org.jruby.RubyClass;
  44. import org.jruby.RubyException;
  45. import org.jruby.RubyInstanceConfig;
  46. import org.jruby.RubyString;
  47. import org.jruby.runtime.Helpers;
  48. import org.jruby.runtime.RubyEvent;
  49. import org.jruby.runtime.ThreadContext;
  50. import org.jruby.runtime.backtrace.RubyStackTraceElement;
  51. import org.jruby.runtime.backtrace.TraceType;
  52. import org.jruby.runtime.builtin.IRubyObject;

  54. public class RaiseException extends JumpException {
  55.     public static final boolean DEBUG = false;
  56.     private static final long serialVersionUID = -7612079169559973951L;
  57.     
  58.     private RubyException exception;
  59.     private String providedMessage;
  60.     private boolean nativeException;

  62.     /**
  63.      * Construct a new RaiseException to wrap the given Ruby exception for Java-land
  64.      * throwing purposes.
  65.      *
  66.      * This constructor will generate a backtrace using the Java
  67.      * stack trace and the interpreted Ruby frames for the current thread.
  68.      *
  69.      * @param actException The Ruby exception to wrap
  70.      */
  71.     public RaiseException(RubyException actException) {
  72.         this(actException, false);
  73.     }

  75.     /**
  76.      * Construct a new RaiseException to wrap the given Ruby exception for Java-land
  77.      * throwing purposes.
  78.      * 
  79.      * This constructor will not generate a backtrace and will instead use the
  80.      * one specified by the
  81.      * 
  82.      * @param exception The Ruby exception to wrap
  83.      * @param backtrace
  84.      */
  85.     public RaiseException(RubyException exception, IRubyObject backtrace) {
  86.         super(exception.message.toString());
  87.         if (DEBUG) {
  88.             Thread.dumpStack();
  89.         }
  90.         setException(exception, false);
  91.         preRaise(exception.getRuntime().getCurrentContext(), backtrace);
  92.     }

  94.     public RaiseException(Ruby runtime, RubyClass excptnClass, String msg, boolean nativeException) {
  95.         super(msg);
  96.         if (msg == null) {
  97.             msg = "No message available";
  98.         }
  99.         providedMessage = "(" + excptnClass.getName() + ") " + msg;
  100.         this.nativeException = nativeException;
  101.         if (DEBUG) {
  102.             Thread.dumpStack();
  103.         }
  104.         setException((RubyException) Helpers.invoke(
  105.                 runtime.getCurrentContext(),
  106.                 excptnClass,
  107.                 "new",
  108.                 RubyString.newUnicodeString(excptnClass.getRuntime(), msg)),
  109.                 nativeException);
  110.         preRaise(runtime.getCurrentContext());
  111.     }

  113.     public RaiseException(Ruby runtime, RubyClass excptnClass, String msg, IRubyObject backtrace, boolean nativeException) {
  114.         super(msg);
  115.         if (msg == null) {
  116.             msg = "No message available";
  117.         }
  118.         providedMessage = "(" + excptnClass.getName() + ") " + msg;
  119.         this.nativeException = nativeException;
  120.         if (DEBUG) {
  121.             Thread.dumpStack();
  122.         }
  123.         setException((RubyException) Helpers.invoke(
  124.                 runtime.getCurrentContext(),
  125.                 excptnClass,
  126.                 "new",
  127.                 RubyString.newUnicodeString(excptnClass.getRuntime(), msg)),
  128.                 nativeException);
  129.         preRaise(runtime.getCurrentContext(), backtrace);
  130.     }

  132.     public RaiseException(RubyException exception, boolean isNativeException) {
  133.         super(exception.message.toString());
  134.         if (DEBUG) {
  135.             Thread.dumpStack();
  136.         }
  137.         this.nativeException = isNativeException;
  138.         setException(exception, isNativeException);
  139.         preRaise(exception.getRuntime().getCurrentContext());
  140.     }

  142.     public RaiseException(Throwable cause, NativeException nativeException) {
  143.         super(buildMessage(cause), cause);
  144.         providedMessage = buildMessage(cause);
  145.         setException(nativeException, true);
  146.         preRaise(nativeException.getRuntime().getCurrentContext(), nativeException.getCause().getStackTrace());
  147.         setStackTrace(RaiseException.javaTraceFromRubyTrace(exception.getBacktraceElements()));
  148.     }

  150.     /**
  151.      * Method still in use by jruby-openssl <= 0.5.2
  152.      */
  153.     public static RaiseException createNativeRaiseException(Ruby runtime, Throwable cause) {
  154.         return createNativeRaiseException(runtime, cause, null);
  155.     }

  157.     public static RaiseException createNativeRaiseException(Ruby runtime, Throwable cause, Member target) {
  158.         NativeException nativeException = new NativeException(runtime, runtime.getNativeException(), cause);

  160.         // FIXME: someday, add back filtering of reflection/handle methods between JRuby and target

  162.         return new RaiseException(cause, nativeException);
  163.     }

  165.     private static String buildMessage(Throwable exception) {
  166.         StringBuilder sb = new StringBuilder();
  167.         StringWriter stackTrace = new StringWriter();
  168.         exception.printStackTrace(new PrintWriter(stackTrace));
  169.     
  170.         sb.append("Native Exception: '").append(exception.getClass()).append("'; ");
  171.         sb.append("Message: ").append(exception.getMessage()).append("; ");
  172.         sb.append("StackTrace: ").append(stackTrace.getBuffer().toString());

  174.         return sb.toString();
  175.     }

  177.     @Override
  178.     public String getMessage() {
  179.         if (providedMessage == null) {
  180.             providedMessage = "(" + exception.getMetaClass().getBaseName() + ") " + exception.message(exception.getRuntime().getCurrentContext()).asJavaString();
  181.         }
  182.         return providedMessage;
  183.     }

  185.     /**
  186.      * Gets the exception
  187.      * @return Returns a RubyException
  188.      */
  189.     public RubyException getException() {
  190.         return exception;
  191.     }

  193.     private void preRaise(ThreadContext context) {
  194.         preRaise(context, (IRubyObject)null);
  195.     }

  197.     private void preRaise(ThreadContext context, StackTraceElement[] javaTrace) {
  198.         context.runtime.incrementExceptionCount();
  199.         doSetLastError(context);
  200.         doCallEventHook(context);

  202.         if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.dumpException(exception);

  204.         exception.prepareIntegratedBacktrace(context, javaTrace);
  205.     }

  207.     private void preRaise(ThreadContext context, IRubyObject backtrace) {
  208.         context.runtime.incrementExceptionCount();
  209.         doSetLastError(context);
  210.         doCallEventHook(context);

  212.         if (RubyInstanceConfig.LOG_EXCEPTIONS) TraceType.dumpException(exception);

  214.         if (backtrace == null) {
  215.             exception.prepareBacktrace(context, nativeException);
  216.         } else {
  217.             exception.forceBacktrace(backtrace);
  218.         }

  220.         // call Throwable.setStackTrace so that when RaiseException appears nested inside another exception,
  221.         // Ruby stack trace gets displayed

  223.         // JRUBY-2673: if wrapping a NativeException, use the actual Java exception's trace as our Java trace
  224.         if (exception instanceof NativeException) {
  225.             setStackTrace(((NativeException)exception).getCause().getStackTrace());
  226.         } else {
  227.             setStackTrace(RaiseException.javaTraceFromRubyTrace(exception.getBacktraceElements()));
  228.         }
  229.     }

  231.     private void doCallEventHook(ThreadContext context) {
  232.         if (context.runtime.hasEventHooks()) {
  233.             context.runtime.callEventHooks(context, RubyEvent.RAISE, context.getFile(), context.getLine(), context.getFrameName(), context.getFrameKlazz());
  234.         }
  235.     }

  237.     private void doSetLastError(ThreadContext context) {
  238.         context.runtime.getGlobalVariables().set("$!", exception);
  239.     }
  240.     
  241.     /**
  242.      * Sets the exception
  243.      * @param newException The exception to set
  244.      */
  245.     protected void setException(RubyException newException, boolean nativeException) {
  246.         this.exception = newException;
  247.         this.nativeException = nativeException;
  248.     }

  250.     public static StackTraceElement[] javaTraceFromRubyTrace(RubyStackTraceElement[] trace) {
  251.         StackTraceElement[] newTrace = new StackTraceElement[trace.length];
  252.         for (int i = 0; i < newTrace.length; i++) {
  253.             newTrace[i] = trace[i].getElement();
  254.         }
  255.         return newTrace;
  256.     }
  257. }
Created with JaCoCo 0.7.3.201501050207