Java UndertowMessages类代码示例

import io.undertow.UndertowMessages; //导入依赖的package包/类
@Override
public void awaitReadable(long l, TimeUnit timeUnit) throws IOException {
    if(Thread.currentThread() == getIoThread()) {
        throw UndertowMessages.MESSAGES.awaitCalledFromIoThread();
    }
    if (data == null) {
        synchronized (lock) {
            if (data == null) {
                try {
                    waiters++;
                    lock.wait(timeUnit.toMillis(l));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new InterruptedIOException();
                } finally {
                    waiters--;
                }
            }
        }
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
public synchronized PathTemplateMatcher<T> add(final PathTemplate template, final T value) {
    Set<PathTemplateHolder> values = pathTemplateMap.get(trimBase(template));
    Set<PathTemplateHolder> newValues;
    if (values == null) {
        newValues = new TreeSet<>();
    } else {
        newValues = new TreeSet<>(values);
    }
    PathTemplateHolder holder = new PathTemplateHolder(value, template);
    if (newValues.contains(holder)) {
        PathTemplate equivalent = null;
        for (PathTemplateHolder item : newValues) {
            if (item.compareTo(holder) == 0) {
                equivalent = item.template;
                break;
            }
        }
        throw UndertowMessages.MESSAGES.matcherAlreadyContainsTemplate(template.getTemplateString(), equivalent.getTemplateString());
    }
    newValues.add(holder);
    pathTemplateMap.put(trimBase(template), newValues);
    buildLengths();
    return this;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
public ServletPathMatch getServletHandlerByPath(final String path) {
    ServletPathMatch exact = exactPathMatches.get(path);
    if (exact != null) {
        return exact;
    }
    PathMatch match = prefixMatches.get(path);
    if (match != null) {
        return handleMatch(path, match, path.lastIndexOf('.'));
    }
    int extensionPos = -1;
    for (int i = path.length() - 1; i >= 0; --i) {
        final char c = path.charAt(i);
         if (c == '/') {
            final String part = path.substring(0, i);
            match = prefixMatches.get(part);
            if (match != null) {
                return handleMatch(path, match, extensionPos);
            }
        } else if (c == '.' && extensionPos == -1) {
                extensionPos = i;
        }
    }
    //this should never happen
    //as the default servlet is aways registered under /*
    throw UndertowMessages.MESSAGES.servletPathMatchFailed();
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
private void queue(final ByteBuffer[] byteBuffers, final IoCallback ioCallback) {
    //if data is sent from withing the callback we queue it, to prevent the stack growing indefinitely
    if (next != null || pendingFile != null) {
        throw UndertowMessages.MESSAGES.dataAlreadyQueued();
    }
    StringBuilder builder = new StringBuilder();
    for (ByteBuffer buffer : byteBuffers) {
        try {
            builder.append(charsetDecoder.decode(buffer));
        } catch (CharacterCodingException e) {
            ioCallback.onException(exchange, this, e);
            return;
        }
    }
    this.next = builder.toString();
    queuedCallback = ioCallback;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
@Override
public int read(final byte[] b, final int off, final int len) throws IOException {
    if (anyAreSet(state, FLAG_CLOSED)) {
        throw UndertowMessages.MESSAGES.streamIsClosed();
    }
    readIntoBuffer();
    if (anyAreSet(state, FLAG_FINISHED)) {
        return -1;
    }
    if (len == 0) {
        return 0;
    }
    ByteBuffer buffer = pooled.getResource();
    int copied = Buffers.copy(ByteBuffer.wrap(b, off, len), buffer);
    if (!buffer.hasRemaining()) {
        pooled.free();
        pooled = null;
    }
    return copied;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
@Override
public <T> void addToAttachmentList(AttachmentKey<AttachmentList<T>> key, T value) {

    if (key == null) {
        throw UndertowMessages.MESSAGES.argumentCannotBeNull("key");
    }
    final Map<AttachmentKey<?>, Object> attachments = this.attachments;
    synchronized (attachments) {
        final List<T> list = key.cast(attachments.get(key));
        if (list == null) {
            final AttachmentList<T> newList = new AttachmentList<T>((Class<T>) Object.class);
            attachments.put(key, newList);
            newList.add(value);
        } else {
            list.add(value);
        }
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
@Override
public void connect(ClientCallback<ClientConnection> listener, InetSocketAddress bindAddress, URI uri, XnioWorker worker, XnioSsl ssl, Pool<ByteBuffer> bufferPool, OptionMap options) {
    if (uri.getScheme().equals("https")) {
        if (ssl == null) {
            listener.failed(UndertowMessages.MESSAGES.sslWasNull());
            return;
        }
        if (bindAddress == null) {
            ssl.openSslConnection(worker, new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 443 : uri.getPort()), createOpenListener(listener, bufferPool, options), options).addNotifier(createNotifier(listener), null);
        } else {
            ssl.openSslConnection(worker, bindAddress, new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 443 : uri.getPort()), createOpenListener(listener, bufferPool, options), options).addNotifier(createNotifier(listener), null);
        }
    } else {
        if (bindAddress == null) {
            worker.openStreamConnection(new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 80 : uri.getPort()), createOpenListener(listener, bufferPool, options), options).addNotifier(createNotifier(listener), null);
        } else {
            worker.openStreamConnection(bindAddress, new InetSocketAddress(uri.getHost(), uri.getPort() == -1 ? 80 : uri.getPort()), createOpenListener(listener, bufferPool, options), null, options).addNotifier(createNotifier(listener), null);
        }
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
/**
 * Adds a path prefix and a handler for that path. If the path does not start
 * with a / then one will be prepended.
 * <p/>
 * The match is done on a prefix bases, so registering /foo will also match /bar. Exact
 * path matches are taken into account first.
 * <p/>
 * If / is specified as the path then it will replace the default handler.
 *
 * @param path    The path
 * @param handler The handler
 */
public synchronized PathMatcher addPrefixPath(final String path, final T handler) {
    if (path.isEmpty()) {
        throw UndertowMessages.MESSAGES.pathMustBeSpecified();
    }

    final String normalizedPath = this.normalizeSlashes(path);

    if (PathMatcher.STRING_PATH_SEPARATOR.equals(normalizedPath)) {
        this.defaultHandler = handler;
        return this;
    }

    paths.put(normalizedPath, handler);

    buildLengths();
    return this;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
/**
 * Sends a continue response using blocking IO
 *
 * @param exchange The exchange
 */
public static void sendContinueResponseBlocking(final HttpServerExchange exchange) throws IOException {
    if (!exchange.isResponseChannelAvailable()) {
        throw UndertowMessages.MESSAGES.cannotSendContinueResponse();
    }
    if(exchange.getAttachment(ALREADY_SENT) != null) {
        return;
    }
    HttpServerExchange newExchange = exchange.getConnection().sendOutOfBandResponse(exchange);
    exchange.putAttachment(ALREADY_SENT, true);
    newExchange.setResponseCode(StatusCodes.CONTINUE);
    newExchange.getResponseHeaders().put(Headers.CONTENT_LENGTH, 0);
    newExchange.startBlocking();
    newExchange.getOutputStream().close();
    newExchange.getInputStream().close();
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
private static Map<String, HandlerBuilder> loadBuilders(final ClassLoader classLoader) {
    ServiceLoader<HandlerBuilder> loader = ServiceLoader.load(HandlerBuilder.class, classLoader);
    final Map<String, HandlerBuilder> ret = new HashMap<>();
    for (HandlerBuilder builder : loader) {
        if (ret.containsKey(builder.name())) {
            if (ret.get(builder.name()).getClass() != builder.getClass()) {
                throw UndertowMessages.MESSAGES.moreThanOneHandlerWithName(builder.name(), builder.getClass(), ret.get(builder.name()).getClass());
            }
        } else {
            ret.put(builder.name(), builder);
        }
    }
    return ret;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
public SpdyOpenListener(final Pool<ByteBuffer> pool, final Pool<ByteBuffer> heapBufferPool, final OptionMap undertowOptions) {
    this.undertowOptions = undertowOptions;
    this.bufferPool = pool;
    Pooled<ByteBuffer> buf = pool.allocate();
    this.bufferSize = buf.getResource().remaining();
    buf.free();
    this.heapBufferPool = heapBufferPool;
    Pooled<ByteBuffer> buff = heapBufferPool.allocate();
    try {
        if (!buff.getResource().hasArray()) {
            throw UndertowMessages.MESSAGES.mustProvideHeapBuffer();
        }
    } finally {
        buff.free();
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
public SpdyPlainOpenListener(final Pool<ByteBuffer> pool, final Pool<ByteBuffer> heapBufferPool, final OptionMap undertowOptions) {
    this.undertowOptions = undertowOptions;
    this.bufferPool = pool;
    Pooled<ByteBuffer> buf = pool.allocate();
    this.bufferSize = buf.getResource().remaining();
    buf.free();
    this.heapBufferPool = heapBufferPool;
    Pooled<ByteBuffer> buff = heapBufferPool.allocate();
    try {
        if (!buff.getResource().hasArray()) {
            throw UndertowMessages.MESSAGES.mustProvideHeapBuffer();
        }
    } finally {
        buff.free();
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
@Override
public void awaitWritable() throws IOException {
    if(Thread.currentThread() == getIoThread()) {
        throw UndertowMessages.MESSAGES.awaitCalledFromIoThread();
    }
    synchronized (lock) {
        if (anyAreSet(state, STATE_CLOSED) || broken) {
            return;
        }
        if (readyForFlush) {
            try {
                waiterCount++;
                //we need to re-check after incrementing the waiters count

                if(readyForFlush && !anyAreSet(state, STATE_CLOSED) && !broken) {
                    lock.wait();
                }
            } catch (InterruptedException e) {
                throw new InterruptedIOException();
            } finally {
                waiterCount--;
            }
        }
    }
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
public synchronized PathMatcher removePrefixPath(final String path) {
    if (path == null || path.isEmpty()) {
        throw UndertowMessages.MESSAGES.pathMustBeSpecified();
    }

    final String normalizedPath = this.normalizeSlashes(path);

    if (PathMatcher.STRING_PATH_SEPARATOR.equals(normalizedPath)) {
        defaultHandler = null;
        return this;
    }

    paths.remove(normalizedPath);

    buildLengths();
    return this;
}
 

import io.undertow.UndertowMessages; //导入依赖的package包/类
void invalidate(final HttpServerExchange exchange, SessionListener.SessionDestroyedReason reason) {
    synchronized(SessionImpl.this) {
        if (timerCancelKey != null) {
            timerCancelKey.remove();
        }
        InMemorySession sess = sessionManager.sessions.get(sessionId);
        if (sess == null) {
            if (reason == SessionListener.SessionDestroyedReason.INVALIDATED) {
                throw UndertowMessages.MESSAGES.sessionAlreadyInvalidated();
            }
            return;
        }
        invalidationStarted = true;
    }
    sessionManager.sessionListeners.sessionDestroyed(this, exchange, reason);
    sessionManager.sessions.remove(sessionId);
    if (exchange != null) {
        sessionCookieConfig.clearSession(exchange, this.getId());
    }
}