Java tutorial
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright (c) 2009-2010 Oracle and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development * and Distribution License("CDDL") (collectively, the "License"). You * may not use this file except in compliance with the License. You can * obtain a copy of the License at * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html * or packager/legal/LICENSE.txt. See the License for the specific * language governing permissions and limitations under the License. * * When distributing the software, include this License Header Notice in each * file and include the License file at packager/legal/LICENSE.txt. * * GPL Classpath Exception: * Oracle designates this particular file as subject to the "Classpath" * exception as provided by Oracle in the GPL Version 2 section of the License * file that accompanied this code. * * Modifications: * If applicable, add the following below the License Header, with the fields * enclosed by brackets [] replaced by your own identifying information: * "Portions Copyright [year] [name of copyright owner]" * * Contributor(s): * If you wish your version of this file to be governed by only the CDDL or * only the GPL Version 2, indicate your decision by adding "[Contributor] * elects to include this software in this distribution under the [CDDL or GPL * Version 2] license." If you don't indicate a single choice of license, a * recipient has the option to distribute your version of this file under * either the CDDL, the GPL Version 2 or to extend the choice of license to * its licensees as provided above. However, if you add GPL Version 2 code * and therefore, elected the GPL Version 2 license, then the option applies * only if the new code is made subject to such option by the copyright * holder. * * * This file incorporates work covered by the following copyright and * permission notice: * * Copyright 2004 The Apache Software Foundation * * Licensed 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 com.sun.grizzly.http.jk.common; import com.sun.grizzly.util.LoggerUtils; import java.io.IOException; import javax.management.ObjectName; import com.sun.grizzly.http.jk.apr.AprImpl; import com.sun.grizzly.http.jk.core.JkChannel; import com.sun.grizzly.http.jk.core.JkHandler; import com.sun.grizzly.http.jk.core.Msg; import com.sun.grizzly.http.jk.core.MsgContext; import com.sun.grizzly.util.buf.ByteChunk; import com.sun.grizzly.util.buf.C2BConverter; import com.sun.grizzly.util.buf.MessageBytes; import java.util.logging.Level; import org.apache.commons.modeler.Registry; /** * Base class for components using native code ( libjkjni.so ). * It allows to access the jk_env and wrap ( 'box' ? ) a native * jk component, and call it's methods. * * Note that get/setAttribute are expensive ( Strings, etc ), * invoke() is were all optimizations are done. We do recycle * all memory on both C and java sides ( the only exception is * when we attempt pinning but the VM doesn't support it ). The * low level optimizations from ByteBuffer, etc are used to * reduce the overhead of passing strings. * * @author Costin Manolache */ public class JniHandler extends JkHandler { protected AprImpl apr; // The native side handler protected long nativeJkHandlerP; protected String jkHome; // Dispatch table codes. Hardcoded for now, will change when we have more handlers. public static final int JK_HANDLE_JNI_DISPATCH = 0x15; public static final int JK_HANDLE_SHM_DISPATCH = 0x16; public static final int MSG_NOTE = 0; public static final int MB_NOTE = 2; private boolean paused = false; public JniHandler() { } /** */ public void setJkHome(String s) { jkHome = s; } public String getJkHome() { return jkHome; } /** You must call initNative() inside the component init() */ public void init() throws IOException { // static field init, temp } protected void initNative(String nativeComponentName) { apr = (AprImpl) wEnv.getHandler("apr"); if (apr == null) { // In most cases we can just load it automatically. // that requires all libs to be installed in standard places // ( LD_LIBRARY_PATH, /usr/lib try { apr = new AprImpl(); wEnv.addHandler("apr", apr); apr.init(); if (oname != null) { ObjectName aprname = new ObjectName(oname.getDomain() + ":type=JkHandler, name=apr"); Registry.getRegistry(null, null).registerComponent(apr, aprname, null); } } catch (Throwable t) { LoggerUtils.getLogger().log(Level.FINEST, "Can't load apr", t); apr = null; } } if (apr == null || !apr.isLoaded()) { if (LoggerUtils.getLogger().isLoggable(Level.FINEST)) { LoggerUtils.getLogger().log(Level.FINEST, "No apr, disabling jni proxy "); } apr = null; return; } try { long xEnv = apr.getJkEnv(); nativeJkHandlerP = apr.getJkHandler(xEnv, nativeComponentName); if (nativeJkHandlerP == 0) { LoggerUtils.getLogger().log(Level.FINEST, "Component not found, creating it " + nativeComponentName); nativeJkHandlerP = apr.createJkHandler(xEnv, nativeComponentName); } LoggerUtils.getLogger().log(Level.FINEST, "Native proxy " + nativeJkHandlerP); apr.releaseJkEnv(xEnv); } catch (Throwable t) { apr = null; } } public void appendString(Msg msg, String s, C2BConverter charsetDecoder) throws IOException { ByteChunk bc = charsetDecoder.getByteChunk(); charsetDecoder.recycle(); charsetDecoder.convert(s); charsetDecoder.flushBuffer(); msg.appendByteChunk(bc); } public void pause() throws Exception { synchronized (this) { paused = true; } } public void resume() throws Exception { synchronized (this) { paused = false; notifyAll(); } } /** Create a msg context to be used with the shm channel */ public MsgContext createMsgContext() { if (nativeJkHandlerP == 0 || apr == null) { return null; } synchronized (this) { try { while (paused) { wait(); } } catch (InterruptedException ie) { // Ignore, since it can't happen } } try { MsgContext msgCtx = new MsgContext(); MsgAjp msg = new MsgAjp(); msgCtx.setSource((JkChannel) this); msgCtx.setWorkerEnv(wEnv); msgCtx.setNext(this); msgCtx.setMsg(MSG_NOTE, msg); // XXX Use noteId C2BConverter c2b = new C2BConverter("iso-8859-1"); msgCtx.setConverter(c2b); MessageBytes tmpMB = MessageBytes.newInstance(); msgCtx.setNote(MB_NOTE, tmpMB); return msgCtx; } catch (Exception ex) { LoggerUtils.getLogger().log(Level.SEVERE, "Can't create endpoint", ex); return null; } } public void setNativeAttribute(String name, String val) throws IOException { if (apr == null) { return; } if (nativeJkHandlerP == 0) { LoggerUtils.getLogger().log(Level.SEVERE, "Unitialized component " + name + " " + val); return; } long xEnv = apr.getJkEnv(); apr.jkSetAttribute(xEnv, nativeJkHandlerP, name, val); apr.releaseJkEnv(xEnv); } public void initJkComponent() throws IOException { if (apr == null) { return; } if (nativeJkHandlerP == 0) { LoggerUtils.getLogger().log(Level.SEVERE, "Unitialized component "); return; } long xEnv = apr.getJkEnv(); apr.jkInit(xEnv, nativeJkHandlerP); apr.releaseJkEnv(xEnv); } public void destroyJkComponent() throws IOException { if (apr == null) { return; } if (nativeJkHandlerP == 0) { LoggerUtils.getLogger().log(Level.SEVERE, "Unitialized component "); return; } long xEnv = apr.getJkEnv(); apr.jkDestroy(xEnv, nativeJkHandlerP); apr.releaseJkEnv(xEnv); } protected void setNativeEndpoint(MsgContext msgCtx) { long xEnv = apr.getJkEnv(); msgCtx.setJniEnv(xEnv); long epP = apr.createJkHandler(xEnv, "endpoint"); LoggerUtils.getLogger().log(Level.FINEST, "create ep " + epP); if (epP == 0) { return; } apr.jkInit(xEnv, epP); msgCtx.setJniContext(epP); } protected void recycleNative(MsgContext ep) { apr.jkRecycle(ep.getJniEnv(), ep.getJniContext()); } /** send and get the response in the same buffer. This calls the * method on the wrapped jk_bean object. */ protected int nativeDispatch(Msg msg, MsgContext ep, int code, int raw) throws IOException { if (LoggerUtils.getLogger().isLoggable(Level.FINEST)) { LoggerUtils.getLogger().log(Level.FINEST, "Sending packet " + code + " " + raw); } if (raw == 0) { msg.end(); } // Create ( or reuse ) the jk_endpoint ( the native pair of // MsgContext ) long xEnv = ep.getJniEnv(); long nativeContext = ep.getJniContext(); if (nativeContext == 0 || xEnv == 0) { setNativeEndpoint(ep); xEnv = ep.getJniEnv(); nativeContext = ep.getJniContext(); } if (xEnv == 0 || nativeContext == 0 || nativeJkHandlerP == 0) { LoggerUtils.getLogger().log(Level.SEVERE, "invokeNative: Null pointer "); return -1; } // Will process the message in the current thread. // No wait needed to receive the response, if any int status = AprImpl.jkInvoke(xEnv, nativeJkHandlerP, nativeContext, code, msg.getBuffer(), 0, msg.getLen(), raw); if (status != 0 && status != 2) { LoggerUtils.getLogger().log(Level.SEVERE, "nativeDispatch: error " + status, new Throwable()); } if (LoggerUtils.getLogger().isLoggable(Level.FINEST)) { LoggerUtils.getLogger().log(Level.FINEST, "Sending packet - done " + status); } return status; } /** Base implementation for invoke. Dispatch the action to the native * code, where invoke() is called on the wrapped jk_bean. */ public int invoke(Msg msg, MsgContext ep) throws IOException { long xEnv = ep.getJniEnv(); int type = ep.getType(); int status = nativeDispatch(msg, ep, type, 0); apr.jkRecycle(xEnv, ep.getJniContext()); apr.releaseJkEnv(xEnv); return status; } }