/** * This method is called when receiving a GO_AWAY from the other peer. We check the close state to * act appropriately: * * <p>* NOT_CLOSED: we move to REMOTELY_CLOSED and queue a disconnect, so that the content of the * queue is written, and then the connection closed. We notify the application after being * terminated. See <code>HTTP2Session.ControlEntry#succeeded()</code> * In all other cases, we do * nothing since other methods are already performing their actions. * * @param frame the GO_AWAY frame that has been received. * @see #close(int, String, Callback) * @see #onShutdown() * @see #onIdleTimeout() */ @Override public void onGoAway(final GoAwayFrame frame) { if (LOG.isDebugEnabled()) LOG.debug("Received {}", frame); while (true) { CloseState current = closed.get(); switch (current) { case NOT_CLOSED: { if (closed.compareAndSet(current, CloseState.REMOTELY_CLOSED)) { // We received a GO_AWAY, so try to write // what's in the queue and then disconnect. notifyClose(this, frame); control(null, Callback.NOOP, new DisconnectFrame()); return; } break; } default: { if (LOG.isDebugEnabled()) LOG.debug("Ignored {}, already closed", frame); return; } } } }
@Override protected SelectChannelEndPoint newEndPoint( SocketChannel channel, SelectSet selectSet, SelectionKey key) throws IOException { // We're connected, cancel the connect timeout Timeout.Task connectTimeout = _connectingChannels.remove(channel); if (connectTimeout != null) connectTimeout.cancel(); if (LOG.isDebugEnabled()) LOG.debug("Channels with connection pending: {}", _connectingChannels.size()); // key should have destination at this point (will be replaced by endpoint after this call) HttpDestination dest = (HttpDestination) key.attachment(); SelectChannelEndPoint scep = new SelectChannelEndPoint(channel, selectSet, key, (int) _httpClient.getIdleTimeout()); AsyncEndPoint ep = scep; if (dest.isSecure()) { LOG.debug("secure to {}, proxied={}", channel, dest.isProxied()); ep = new UpgradableEndPoint(ep, newSslEngine(channel)); } AsyncConnection connection = selectSet.getManager().newConnection(channel, ep, key.attachment()); ep.setConnection(connection); AbstractHttpConnection httpConnection = (AbstractHttpConnection) connection; httpConnection.setDestination(dest); if (dest.isSecure() && !dest.isProxied()) ((UpgradableEndPoint) ep).upgrade(); dest.onNewConnection(httpConnection); return scep; }
/** * Called to indicate that the last write has been performed. It updates the state and performs * cleanup operations. */ void closed() { while (true) { OutputState state = _state.get(); switch (state) { case CLOSED: { return; } case UNREADY: { if (_state.compareAndSet(state, OutputState.ERROR)) _writeListener.onError( _onError == null ? new EofException("Async closed") : _onError); break; } default: { if (!_state.compareAndSet(state, OutputState.CLOSED)) break; try { _channel.getResponse().closeOutput(); } catch (Throwable x) { if (LOG.isDebugEnabled()) LOG.debug(x); abort(x); } finally { releaseBuffer(); } // Return even if an exception is thrown by closeOutput(). return; } } } }
/** @see Proxy#startProxy() */ public void startProxy() { _started = true; if (_tx.isCompleted()) throw new IllegalStateException("Transaction has completed"); if (!_parallel && _actives > 0) return; // Patch TMP fix for CIPANGO 8 CallSession callSession = _tx.getRequest().getCallSession(); SessionManager cm = callSession.getServer().getSessionManager(); SessionScope work = cm.openScope(callSession); try { // End patch while (LazyList.size(_targets) > 0) { Branch branch = (Branch) LazyList.get(_targets, 0); _targets = LazyList.remove(_targets, 0); if (LOG.isDebugEnabled()) LOG.debug("Proxying to {} ", branch.getUri(), null); branch.start(); if (!_parallel) break; } // Patch TMP fix for CIPANGO 8 } finally { work.close(); } // End patch }
public Object call(Object obj, Object... args) { if ((this.pojo == null) || (this.method == null)) { LOG.warn("Cannot execute call: pojo={}, method={}", pojo, method); return null; // no call event method determined } if (obj == null) { String err = String.format("Cannot call %s on null object", this.method); LOG.warn(new RuntimeException(err)); return null; } if (args.length < paramTypes.length) { throw new IllegalArgumentException( "Call arguments length [" + args.length + "] must always be greater than or equal to captured args length [" + paramTypes.length + "]"); } try { return this.method.invoke(obj, args); } catch (Throwable t) { String err = formatMethodCallError(args); throw unwrapRuntimeException(err, t); } }
/** * Load user's info from database. * * @param userName */ @Override protected UserIdentity loadUser(String userName) { try { try (Connection connection = getConnection(); PreparedStatement statement1 = connection.prepareStatement(_userSql)) { statement1.setObject(1, userName); try (ResultSet rs1 = statement1.executeQuery()) { if (rs1.next()) { int key = rs1.getInt(_userTableKey); String credentials = rs1.getString(_userTablePasswordField); List<String> roles = new ArrayList<String>(); try (PreparedStatement statement2 = connection.prepareStatement(_roleSql)) { statement2.setInt(1, key); try (ResultSet rs2 = statement2.executeQuery()) { while (rs2.next()) { roles.add(rs2.getString(_roleTableRoleField)); } } } return putUser( userName, Credential.getCredential(credentials), roles.toArray(new String[roles.size()])); } } } } catch (NamingException e) { LOG.warn("No datasource for " + _jndiName, e); } catch (SQLException e) { LOG.warn("Problem loading user info for " + userName, e); } return null; }
public void makeTempDirectory(File parent, WebAppContext context, boolean deleteExisting) throws IOException { if (parent != null && parent.exists() && parent.canWrite() && parent.isDirectory()) { String temp = getCanonicalNameForWebAppTmpDir(context); File tmpDir = new File(parent, temp); if (deleteExisting && tmpDir.exists()) { if (!IO.delete(tmpDir)) { if (LOG.isDebugEnabled()) LOG.debug("Failed to delete temp dir " + tmpDir); } // If we can't delete the existing tmp dir, create a new one if (tmpDir.exists()) { String old = tmpDir.toString(); tmpDir = File.createTempFile(temp + "_", ""); if (tmpDir.exists()) IO.delete(tmpDir); LOG.warn("Can't reuse " + old + ", using " + tmpDir); } } if (!tmpDir.exists()) tmpDir.mkdir(); // If the parent is not a work directory if (!isTempWorkDirectory(tmpDir)) { tmpDir.deleteOnExit(); } if (LOG.isDebugEnabled()) LOG.debug("Set temp dir " + tmpDir); context.setTempDirectory(tmpDir); } }
/* ------------------------------------------------------------ */ public Object invoke(String name, Object[] params, String[] signature) throws MBeanException, ReflectionException { if (LOG.isDebugEnabled()) LOG.debug("invoke " + name); String methodKey = name + "("; if (signature != null) for (int i = 0; i < signature.length; i++) methodKey += (i > 0 ? "," : "") + signature[i]; methodKey += ")"; ClassLoader old_loader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(_loader); Method method = (Method) _methods.get(methodKey); if (method == null) throw new NoSuchMethodException(methodKey); Object o = _managed; if (method.getDeclaringClass().isInstance(this)) o = this; return method.invoke(o, params); } catch (NoSuchMethodException e) { LOG.warn(Log.EXCEPTION, e); throw new ReflectionException(e); } catch (IllegalAccessException e) { LOG.warn(Log.EXCEPTION, e); throw new MBeanException(e); } catch (InvocationTargetException e) { LOG.warn(Log.EXCEPTION, e); throw new ReflectionException(new Exception(e.getCause())); } finally { Thread.currentThread().setContextClassLoader(old_loader); } }
public static Namelist fromJSONtoNamelist(JSONObject jsonObj) { logger.info("Convert json object to namelist..."); if (jsonObj != null) { String name = jsonObj.getString("_name"); String species = jsonObj.getString("_species"); if (species == null) { JSONObject metadataJSONObj = jsonObj.getJSONObject("metadata"); if (metadataJSONObj != null) { species = metadataJSONObj.getString("species"); } } int size = jsonObj.getInt("_size"); JSONArray data = jsonObj.containsKey("_data") ? jsonObj.getJSONArray("_data") : jsonObj.getJSONArray("gaggle-data"); String[] names = new String[data.size()]; for (int i = 0; i < data.size(); i++) { logger.info("Data item: " + data.getString(i)); names[i] = data.getString(i); } logger.info("Species: " + species + " Names: " + names); Namelist nl = new Namelist(name, species, names); return nl; } return null; }
/** * Parse a resource that is a jar file. * * @param jarResource * @param resolver * @throws Exception */ public void parseJar(Resource jarResource, final ClassNameResolver resolver) throws Exception { if (jarResource == null) return; URI uri = jarResource.getURI(); if (jarResource.toString().endsWith(".jar")) { if (LOG.isDebugEnabled()) { LOG.debug("Scanning jar {}", jarResource); } ; // treat it as a jar that we need to open and scan all entries from InputStream in = jarResource.getInputStream(); if (in == null) return; JarInputStream jar_in = new JarInputStream(in); try { JarEntry entry = jar_in.getNextJarEntry(); while (entry != null) { parseJarEntry(uri, entry, resolver); entry = jar_in.getNextJarEntry(); } } finally { jar_in.close(); } } }
/** * Parse a single entry in a jar file * * @param jar * @param entry * @param resolver * @throws Exception */ protected void parseJarEntry(URI jar, JarEntry entry, final ClassNameResolver resolver) throws Exception { if (jar == null || entry == null) return; // skip directories if (entry.isDirectory()) return; String name = entry.getName(); // check file is a valid class file name if (isValidClassFileName(name) && isValidClassFilePath(name)) { String shortName = name.replace('/', '.').substring(0, name.length() - 6); if ((resolver == null) || (!resolver.isExcluded(shortName) && (!isParsed(shortName) || resolver.shouldOverride(shortName)))) { Resource clazz = Resource.newResource("jar:" + jar + "!/" + name); if (LOG.isDebugEnabled()) { LOG.debug("Scanning class from jar {}", clazz); } ; scanClass(clazz.getInputStream()); } } }
/** * A typical close by a remote peer involves a GO_AWAY frame followed by TCP FIN. This method is * invoked when the TCP FIN is received, or when an exception is thrown while reading, and we * check the close state to act appropriately: * * <p>* NOT_CLOSED: means that the remote peer did not send a GO_AWAY (abrupt close) or there was * an exception while reading, and therefore we terminate. * * <p>* LOCALLY_CLOSED: we have sent the GO_AWAY to the remote peer, which received it and closed * the connection; we queue a disconnect to close the connection on the local side. The GO_AWAY * just shutdown the output, so we need this step to make sure the connection is closed. See * {@link #close(int, String, Callback)}. * * <p>* REMOTELY_CLOSED: we received the GO_AWAY, and the TCP FIN afterwards, so we do nothing * since the handling of the GO_AWAY will take care of closing the connection. See {@link * #onGoAway(GoAwayFrame)}. * * @see #onGoAway(GoAwayFrame) * @see #close(int, String, Callback) * @see #onIdleTimeout() */ @Override public void onShutdown() { if (LOG.isDebugEnabled()) LOG.debug("Shutting down {}", this); switch (closed.get()) { case NOT_CLOSED: { // The other peer did not send a GO_AWAY, no need to be gentle. if (LOG.isDebugEnabled()) LOG.debug("Abrupt close for {}", this); abort(new ClosedChannelException()); break; } case LOCALLY_CLOSED: { // We have closed locally, and only shutdown // the output; now queue a disconnect. control(null, Callback.NOOP, new DisconnectFrame()); break; } case REMOTELY_CLOSED: { // Nothing to do, the GO_AWAY frame we // received will close the connection. break; } default: { break; } } }
protected IStream createRemoteStream(int streamId) { // SPEC: exceeding max concurrent streams is treated as stream error. while (true) { int remoteCount = remoteStreamCount.get(); int maxCount = getMaxRemoteStreams(); if (maxCount >= 0 && remoteCount >= maxCount) { reset(new ResetFrame(streamId, ErrorCode.REFUSED_STREAM_ERROR.code), Callback.NOOP); return null; } if (remoteStreamCount.compareAndSet(remoteCount, remoteCount + 1)) break; } IStream stream = newStream(streamId, false); // SPEC: duplicate stream is treated as connection error. if (streams.putIfAbsent(streamId, stream) == null) { updateLastStreamId(streamId); stream.setIdleTimeout(getStreamIdleTimeout()); flowControl.onStreamCreated(stream); if (LOG.isDebugEnabled()) LOG.debug("Created remote {}", stream); return stream; } else { close(ErrorCode.PROTOCOL_ERROR.code, "duplicate_stream", Callback.NOOP); return null; } }
/** * Invoked internally and by applications to send a GO_AWAY frame to the other peer. We check the * close state to act appropriately: * * <p>* NOT_CLOSED: we move to LOCALLY_CLOSED and queue a GO_AWAY. When the GO_AWAY has been * written, it will only cause the output to be shut down (not the connection closed), so that the * application can still read frames arriving from the other peer. Ideally the other peer will * notice the GO_AWAY and close the connection. When that happen, we close the connection from * {@link #onShutdown()}. Otherwise, the idle timeout mechanism will close the connection, see * {@link #onIdleTimeout()}. * * <p>* In all other cases, we do nothing since other methods are already performing their * actions. * * @param error the error code * @param reason the reason * @param callback the callback to invoke when the operation is complete * @see #onGoAway(GoAwayFrame) * @see #onShutdown() * @see #onIdleTimeout() */ @Override public boolean close(int error, String reason, Callback callback) { while (true) { CloseState current = closed.get(); switch (current) { case NOT_CLOSED: { if (closed.compareAndSet(current, CloseState.LOCALLY_CLOSED)) { byte[] payload = null; if (reason != null) { // Trim the reason to avoid attack vectors. reason = reason.substring(0, Math.min(reason.length(), 32)); payload = reason.getBytes(StandardCharsets.UTF_8); } GoAwayFrame frame = new GoAwayFrame(lastStreamId.get(), error, payload); control(null, callback, frame); return true; } break; } default: { if (LOG.isDebugEnabled()) LOG.debug("Ignoring close {}/{}, already closed", error, reason); callback.succeeded(); return false; } } } }
/* Handle a request from a connection. * Called to handle a request on the connection when either the header has been received, * or after the entire request has been received (for short requests of known length), or * on the dispatch of an async request. */ public void handleAsync(AbstractHttpConnection connection) throws IOException, ServletException { final AsyncContinuation async = connection.getRequest().getAsyncContinuation(); final AsyncContinuation.AsyncEventState state = async.getAsyncEventState(); final Request baseRequest = connection.getRequest(); final String path = state.getPath(); if (path != null) { // this is a dispatch with a path final String contextPath = state.getServletContext().getContextPath(); HttpURI uri = new HttpURI(URIUtil.addPaths(contextPath, path)); baseRequest.setUri(uri); baseRequest.setRequestURI(null); baseRequest.setPathInfo(baseRequest.getRequestURI()); if (uri.getQuery() != null) baseRequest.mergeQueryString(uri.getQuery()); } final String target = baseRequest.getPathInfo(); final HttpServletRequest request = (HttpServletRequest) async.getRequest(); final HttpServletResponse response = (HttpServletResponse) async.getResponse(); if (LOG.isDebugEnabled()) { LOG.debug("REQUEST " + target + " on " + connection); handle(target, baseRequest, request, response); LOG.debug("RESPONSE " + target + " " + connection.getResponse().getStatus()); } else handle(target, baseRequest, request, response); }
private void serviceDeliver( String targetId, HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws ServletException, IOException { if (gateway.getClientDelegate(targetId) == null) { // Expired client tries to deliver without handshake httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED); return; } byte[] body = Utils.read(httpRequest.getInputStream()); RHTTPResponse response = RHTTPResponse.fromFrameBytes(body); ExternalRequest externalRequest = gateway.removeExternalRequest(response.getId()); if (externalRequest != null) { externalRequest.respond(response); logger.debug( "Deliver request from device {}, gateway request {}, response {}", new Object[] {targetId, externalRequest, response}); } else { // We can arrive here for a race with the continuation expiration, which expired just before // the gateway client responded with a valid response; log this case ignore it. logger.debug( "Deliver request from device {}, missing gateway request, response {}", targetId, response); } }
public String expand(String str, Stack<String> seenStack) { if (str == null) { return str; } if (str.indexOf("${") < 0) { // Contains no potential expressions. return str; } Matcher mat = __propertyPattern.matcher(str); StringBuilder expanded = new StringBuilder(); int offset = 0; String property; String value; while (mat.find(offset)) { property = mat.group(1); // Loop detection if (seenStack.contains(property)) { StringBuilder err = new StringBuilder(); err.append("Property expansion loop detected: "); int idx = seenStack.lastIndexOf(property); for (int i = idx; i < seenStack.size(); i++) { err.append(seenStack.get(i)); err.append(" -> "); } err.append(property); throw new RuntimeException(err.toString()); } seenStack.push(property); // find property name expanded.append(str.subSequence(offset, mat.start())); // get property value value = getString(property); if (value == null) { if (LOG.isDebugEnabled()) LOG.debug("Unable to expand: {}", property); expanded.append(mat.group()); } else { // recursively expand value = expand(value, seenStack); expanded.append(value); } // update offset offset = mat.end(); } // leftover expanded.append(str.substring(offset)); // special case for "$$" if (expanded.indexOf("$$") >= 0) { return expanded.toString().replaceAll("\\$\\$", "\\$"); } return expanded.toString(); }
@Override public void shutdown() { // loop over all the sessions in memory (a few times if necessary to catch sessions that have // been // added while we're running int loop = 100; while (!_sessions.isEmpty() && loop-- > 0) { for (Session session : _sessions.values()) { // if we have a backing store and the session is dirty make sure it is written out if (_sessionDataStore != null) { if (session.getSessionData().isDirty()) { session.willPassivate(); try { _sessionDataStore.store(session.getId(), session.getSessionData()); } catch (Exception e) { LOG.warn(e); } } doDelete(session.getId()); // remove from memory } else { // not preserving sessions on exit try { session.invalidate(); } catch (Exception e) { LOG.ignore(e); } } } } }
/** * Add a name to object binding to this Context. * * @param name a <code>Name</code> value * @param obj an <code>Object</code> value */ public void addBinding(Name name, Object obj) throws NameAlreadyBoundException { String key = name.toString(); Binding binding = new Binding(key, obj); Collection<Listener> list = findListeners(); for (Listener listener : list) { binding = listener.bind(this, binding); if (binding == null) break; } if (__log.isDebugEnabled()) __log.debug( "Adding binding with key=" + key + " obj=" + obj + " for context=" + _name + " as " + binding); if (binding != null) { if (_bindings.containsKey(key)) { if (_supportDeepBinding) { // quietly return (no exception) // this is jndi spec breaking, but is added to support broken // jndi users like openejb. return; } throw new NameAlreadyBoundException(name.toString()); } _bindings.put(key, binding); } }
@Override public void onClose() { super.onClose(); if (LOG.isDebugEnabled()) LOG.debug("onClose {}", this); _writeFlusher.onClose(); _fillInterest.onClose(); }
public GatewayServer( String contextPath, String externalServletPath, String gatewayServletPath, TargetIdRetriever targetIdRetriever) { HandlerCollection handlers = new HandlerCollection(); setHandler(handlers); context = new ServletContextHandler(handlers, contextPath, ServletContextHandler.SESSIONS); // Setup the gateway gateway = createGateway(); // Setup external servlet ExternalServlet externalServlet = new ExternalServlet(gateway, targetIdRetriever); externalServletHolder = new ServletHolder(externalServlet); context.addServlet(externalServletHolder, externalServletPath + "/*"); logger.debug("External servlet mapped to {}/*", externalServletPath); // Setup gateway servlet ConnectorServlet gatewayServlet = new ConnectorServlet(gateway); connectorServletHolder = new ServletHolder(gatewayServlet); connectorServletHolder.setInitParameter("clientTimeout", "15000"); context.addServlet(connectorServletHolder, gatewayServletPath + "/*"); logger.debug("Gateway servlet mapped to {}/*", gatewayServletPath); }
/** * Sends an error 500, performing a special logic to detect whether the request is suspended, to * avoid concurrent writes from the application. * * <p>It may happen that the application suspends, and then throws an exception, while an * application spawned thread writes the response content; in such case, we attempt to commit the * error directly bypassing the {@link ErrorHandler} mechanisms and the response OutputStream. * * @param x the Throwable that caused the problem */ protected void handleException(Throwable x) { try { _request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, x); _request.setAttribute(RequestDispatcher.ERROR_EXCEPTION_TYPE, x.getClass()); if (_state.isSuspended()) { HttpFields fields = new HttpFields(); fields.add(HttpHeader.CONNECTION, HttpHeaderValue.CLOSE); ResponseInfo info = new ResponseInfo( _request.getHttpVersion(), fields, 0, HttpStatus.INTERNAL_SERVER_ERROR_500, null, _request.isHead()); boolean committed = sendResponse(info, null, true); if (!committed) LOG.warn("Could not send response error 500: " + x); _request.getAsyncContext().complete(); } else if (isCommitted()) { if (!(x instanceof EofException)) LOG.warn("Could not send response error 500: " + x); } else { _response.setHeader(HttpHeader.CONNECTION.asString(), HttpHeaderValue.CLOSE.asString()); _response.sendError(500, x.getMessage()); } } catch (IOException e) { // We tried our best, just log LOG.debug("Could not commit response error 500", e); } }
@Override public void onFillable() { // onFillable means that there are encrypted bytes ready to be filled. // however we do not fill them here on this callback, but instead wakeup // the decrypted readInterest and/or writeFlusher so that they will attempt // to do the fill and/or flush again and these calls will do the actually // filling. if (DEBUG) LOG.debug("onFillable enter {}", getEndPoint()); // We have received a close handshake, close the end point to send FIN. if (_decryptedEndPoint.isInputShutdown()) getEndPoint().close(); // wake up whoever is doing the fill or the flush so they can // do all the filling, unwrapping, wrapping and flushing _decryptedEndPoint.getFillInterest().fillable(); // If we are handshaking, then wake up any waiting write as well as it may have been blocked on // the read synchronized (_decryptedEndPoint) { if (_decryptedEndPoint._flushRequiresFillToProgress) { _decryptedEndPoint._flushRequiresFillToProgress = false; getExecutor().execute(_runCompletWrite); } } if (DEBUG) LOG.debug("onFillable exit {}", getEndPoint()); }
/** * Construct a resource from a string. * * @param resource A URL or filename. * @param useCaches controls URLConnection caching * @return A Resource object. * @throws MalformedURLException Problem accessing URI */ public static Resource newResource(String resource, boolean useCaches) throws MalformedURLException { URL url = null; try { // Try to format as a URL? url = new URL(resource); } catch (MalformedURLException e) { if (!resource.startsWith("ftp:") && !resource.startsWith("file:") && !resource.startsWith("jar:")) { try { // It's a file. if (resource.startsWith("./")) resource = resource.substring(2); File file = new File(resource).getCanonicalFile(); return new FileResource(file); } catch (Exception e2) { LOG.debug(Log.EXCEPTION, e2); throw e; } } else { LOG.warn("Bad Resource: " + resource); throw e; } } return newResource(url); }
/** * Check to see if the ServletContainerIntializer loaded via the ServiceLoader came from a jar * that is excluded by the fragment ordering. See ServletSpec 3.0 p.85. * * @param context * @param sci * @return true if excluded */ public boolean isFromExcludedJar( WebAppContext context, ServletContainerInitializer sci, Resource sciResource) throws Exception { if (sci == null) throw new IllegalArgumentException("ServletContainerInitializer null"); if (context == null) throw new IllegalArgumentException("WebAppContext null"); if (LOG.isDebugEnabled()) LOG.debug("Checking {} for jar exclusion", sci); // A ServletContainerInitializer that came from the container's classpath cannot be excluded by // an ordering // of WEB-INF/lib jars if (isFromContainerClassPath(context, sci)) return false; List<Resource> orderedJars = context.getMetaData().getOrderedWebInfJars(); // If no ordering, nothing is excluded if (context.getMetaData().getOrdering() == null) return false; // there is an ordering, but there are no jars resulting from the ordering, everything excluded if (orderedJars.isEmpty()) return true; if (sciResource == null) return false; // not from a jar therefore not from WEB-INF so not excludable URI loadingJarURI = sciResource.getURI(); boolean found = false; Iterator<Resource> itor = orderedJars.iterator(); while (!found && itor.hasNext()) { Resource r = itor.next(); found = r.getURI().equals(loadingJarURI); } return !found; }
/*------------------------------------------------------------ */ @Override public void doStart() throws Exception { super.doStart(); __log.debug("KVStoreSessionManager::doStart method"); String kvstorename = this._session_id_manager.getKvstorename(); if (kvstorename == null) throw new IllegalStateException("kvstore name is null"); String kvstorehosts = this._session_id_manager.getKvstorehosts(); if (kvstorehosts == null) throw new IllegalStateException("kvstore hosts list is null"); this._kvstorehandler = this._session_id_manager.getKVStore(); String[] hhosts = this._session_id_manager.getKvstorehosts().split(","); KVStoreConfig kconfig = new KVStoreConfig(this._session_id_manager.getKvstorename(), hhosts); KVStore kvstore = KVStoreFactory.getStore(kconfig); if (kvstore == null) throw new IllegalStateException( "cannot connect to kvstore, hosts=" + kvstorehosts + ";storename=" + kvstorename); else __log.debug("succesfully connected to the kvstore instance"); this._kvstorehandler = kvstore; if (this._kvstorehandler == null) throw new IllegalStateException("kvstore handler passed from session id manager is null"); String[] hosts = getContextHandler().getVirtualHosts(); if (hosts == null || hosts.length == 0) hosts = new String[] {"::"}; // IPv6 equiv of 0.0.0.0 String contextPath = getContext().getContextPath(); if (contextPath == null || "".equals(contextPath)) { contextPath = "*"; } _contextId = createContextId(hosts, contextPath); this.kvstore_object_ops = new ArrayList<Operation>(); }
/* ------------------------------------------------------------ */ @Override public synchronized String[] list() { if (isDirectory() && _list == null) { List<String> list = null; try { list = listEntries(); } catch (Exception e) { // Sun's JarURLConnection impl for jar: protocol will close a JarFile in its connect() // method if // useCaches == false (eg someone called URLConnection with defaultUseCaches==true). // As their sun.net.www.protocol.jar package caches JarFiles and/or connections, we can wind // up in // the situation where the JarFile we have remembered in our _jarFile member has actually // been closed // by other code. // So, do one retry to drop a connection and get a fresh JarFile LOG.warn("Retrying list:" + e); LOG.debug(e); release(); list = listEntries(); } if (list != null) { _list = new String[list.size()]; list.toArray(_list); } } return _list; }
@Override public void bind(InetSocketAddress addr, int backlog) throws IOException { // check if there is already a connector listening Collection<NetworkConnector> connectors = _server.getBeans(NetworkConnector.class); if (connectors != null) { for (NetworkConnector connector : connectors) { if (connector.getPort() == addr.getPort()) { if (LOG.isDebugEnabled()) LOG.debug("server already bound to port " + addr.getPort() + ", no need to rebind"); return; } } } if (_serverShared) throw new IOException("jetty server is not bound to port " + addr.getPort()); this._addr = addr; if (LOG.isDebugEnabled()) LOG.debug("binding server to port " + addr.getPort()); ServerConnector connector = new ServerConnector(_server); connector.setPort(addr.getPort()); connector.setHost(addr.getHostName()); _server.addConnector(connector); _connectors.put(addr.getHostName() + addr.getPort(), connector); }
/** * Asynchronous send of HTTP content. * * @param httpContent The HTTP content to send * @param callback The callback to use to notify success or failure */ public void sendContent(HttpContent httpContent, Callback callback) { if (LOG.isDebugEnabled()) LOG.debug("sendContent(http={},{})", httpContent, callback); if (BufferUtil.hasContent(_aggregate)) { callback.failed(new IOException("cannot sendContent() after write()")); return; } if (_channel.isCommitted()) { callback.failed(new IOException("committed")); return; } while (true) { switch (_state.get()) { case OPEN: if (!_state.compareAndSet(OutputState.OPEN, OutputState.PENDING)) continue; break; case ERROR: callback.failed(new EofException(_onError)); return; case CLOSED: callback.failed(new EofException("Closed")); return; default: throw new IllegalStateException(); } break; } ByteBuffer buffer = _channel.useDirectBuffers() ? httpContent.getDirectBuffer() : null; if (buffer == null) buffer = httpContent.getIndirectBuffer(); if (buffer != null) { sendContent(buffer, callback); return; } try { ReadableByteChannel rbc = httpContent.getReadableByteChannel(); if (rbc != null) { // Close of the rbc is done by the async sendContent sendContent(rbc, callback); return; } InputStream in = httpContent.getInputStream(); if (in != null) { sendContent(in, callback); return; } throw new IllegalArgumentException("unknown content for " + httpContent); } catch (Throwable th) { abort(th); callback.failed(th); } }
@Override public void sendPong(ByteBuffer data) throws IOException, IllegalArgumentException { if (LOG.isDebugEnabled()) { LOG.debug("sendPong({})", BufferUtil.toDetailString(data)); } jettyRemote.sendPong(data); }