Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* SPDX-License-Identifier: Apache-2.0
*
* The OpenSearch Contributors require contributions made to
* this file be licensed under the Apache-2.0 license or a
* compatible open source license.
*/
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch 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.
*/
/*
* Modifications Copyright OpenSearch Contributors. See
* GitHub history for details.
*/
package org.opensearch.transport;
import org.opensearch.Version;
import org.opensearch.common.breaker.CircuitBreaker;
import org.opensearch.common.bytes.CompositeBytesReference;
import org.opensearch.common.bytes.ReleasableBytesReference;
import org.opensearch.common.lease.Releasable;
import org.opensearch.common.lease.Releasables;
import org.opensearch.common.util.PageCacheRecycler;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.LongSupplier;
import java.util.function.Supplier;
public class InboundPipeline implements Releasable {
private static final ThreadLocal> fragmentList = ThreadLocal.withInitial(ArrayList::new);
private static final InboundMessage PING_MESSAGE = new InboundMessage(null, true);
private final LongSupplier relativeTimeInMillis;
private final StatsTracker statsTracker;
private final InboundDecoder decoder;
private final InboundAggregator aggregator;
private final BiConsumer messageHandler;
private Exception uncaughtException;
private final ArrayDeque pending = new ArrayDeque<>(2);
private boolean isClosed = false;
public InboundPipeline(
Version version,
StatsTracker statsTracker,
PageCacheRecycler recycler,
LongSupplier relativeTimeInMillis,
Supplier circuitBreaker,
Function> registryFunction,
BiConsumer messageHandler
) {
this(
statsTracker,
relativeTimeInMillis,
new InboundDecoder(version, recycler),
new InboundAggregator(circuitBreaker, registryFunction),
messageHandler
);
}
public InboundPipeline(
StatsTracker statsTracker,
LongSupplier relativeTimeInMillis,
InboundDecoder decoder,
InboundAggregator aggregator,
BiConsumer messageHandler
) {
this.relativeTimeInMillis = relativeTimeInMillis;
this.statsTracker = statsTracker;
this.decoder = decoder;
this.aggregator = aggregator;
this.messageHandler = messageHandler;
}
@Override
public void close() {
isClosed = true;
Releasables.closeWhileHandlingException(decoder, aggregator);
Releasables.closeWhileHandlingException(pending);
pending.clear();
}
public void handleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
if (uncaughtException != null) {
throw new IllegalStateException("Pipeline state corrupted by uncaught exception", uncaughtException);
}
try {
doHandleBytes(channel, reference);
} catch (Exception e) {
uncaughtException = e;
throw e;
}
}
public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
channel.getChannelStats().markAccessed(relativeTimeInMillis.getAsLong());
statsTracker.markBytesRead(reference.length());
pending.add(reference.retain());
final ArrayList